@enclave-e3/sdk 0.1.5 → 0.1.7

package/dist/index.js

@@ -1,23 +1,12 @@
 // src/enclave-sdk.ts
-import {
-  createPublicClient,
-  createWalletClient,
-  http,
-  webSocket
-} from "viem";
+import { createPublicClient, createWalletClient, http, webSocket } from "viem";
 import { privateKeyToAccount } from "viem/accounts";
 import { hardhat, mainnet, monadTestnet, sepolia } from "viem/chains";
 import initializeWasm from "@enclave-e3/wasm/init";
-import {
-  CiphernodeRegistryOwnable__factory as CiphernodeRegistryOwnable__factory2,
-  Enclave__factory as Enclave__factory2
-} from "@enclave-e3/contracts/types";
+import { CiphernodeRegistryOwnable__factory as CiphernodeRegistryOwnable__factory2, Enclave__factory as Enclave__factory2 } from "@enclave-e3/contracts/types";
 
 // src/contract-client.ts
-import {
-  CiphernodeRegistryOwnable__factory,
-  Enclave__factory
-} from "@enclave-e3/contracts/types";
+import { CiphernodeRegistryOwnable__factory, Enclave__factory, EnclaveToken__factory } from "@enclave-e3/contracts/types";
 
 // src/utils.ts
 import { encodeAbiParameters } from "viem";
@@ -55,12 +44,14 @@ function generateEventId(log) {
 function getCurrentTimestamp() {
   return Math.floor(Date.now() / 1e3);
 }
-var BFV_PARAMS_SET = {
+var INSECURE_SET_2048_1032193_1 = {
   degree: 2048,
   plaintext_modulus: 1032193,
-  moduli: [0x3fffffff000001n]
+  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,
@@ -68,7 +59,7 @@ var DEFAULT_COMPUTE_PROVIDER_PARAMS = {
 };
 var DEFAULT_E3_CONFIG = {
   threshold_min: 2,
-  threshold_max: 3,
+  threshold_max: 5,
   window_size: 120,
   // 2 minutes in seconds
   duration: 1800,
@@ -76,7 +67,7 @@ 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) {
+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) {
   return encodeAbiParameters(
     [
       {
@@ -85,7 +76,8 @@ function encodeBfvParams(degree = BFV_PARAMS_SET.degree, plaintext_modulus = BFV
         components: [
           { name: "degree", type: "uint256" },
           { name: "plaintext_modulus", type: "uint256" },
-          { name: "moduli", type: "uint256[]" }
+          { name: "moduli", type: "uint256[]" },
+          { name: "error1_variance", type: "string" }
         ]
       }
     ],
@@ -93,12 +85,22 @@ function encodeBfvParams(degree = BFV_PARAMS_SET.degree, plaintext_modulus = BFV
       {
         degree: BigInt(degree),
         plaintext_modulus: BigInt(plaintext_modulus),
-        moduli: [...moduli]
+        moduli: [...moduli],
+        error1_variance
       }
     ]
   );
 }
-function encodeComputeProviderParams(params) {
+function encodeComputeProviderParams(params, mock = false) {
+  if (mock) {
+    return `0x${"0".repeat(32)}`;
+  }
+  const jsonString = JSON.stringify(params);
+  const encoder = new TextEncoder();
+  const bytes = encoder.encode(jsonString);
+  return `0x${Array.from(bytes, (byte) => byte.toString(16).padStart(2, "0")).join("")}`;
+}
+function encodeCustomParams(params) {
   const jsonString = JSON.stringify(params);
   const encoder = new TextEncoder();
   const bytes = encoder.encode(jsonString);
@@ -111,9 +113,7 @@ function calculateStartWindow(windowSize = DEFAULT_E3_CONFIG.window_size) {
 function decodePlaintextOutput(plaintextOutput) {
   try {
     const hex = plaintextOutput.startsWith("0x") ? plaintextOutput.slice(2) : plaintextOutput;
-    const bytes = new Uint8Array(
-      hex.match(/.{1,2}/g)?.map((byte) => parseInt(byte, 16)) || []
-    );
+    const bytes = new Uint8Array(hex.match(/.{1,2}/g)?.map((byte) => parseInt(byte, 16)) || []);
     if (bytes.length < 8) {
       console.warn("Plaintext output too short for u64 decoding");
       return null;
@@ -131,7 +131,8 @@ function decodePlaintextOutput(plaintextOutput) {
 var ContractClient = class {
   constructor(publicClient, walletClient, addresses = {
     enclave: "0x0000000000000000000000000000000000000000",
-    ciphernodeRegistry: "0x0000000000000000000000000000000000000000"
+    ciphernodeRegistry: "0x0000000000000000000000000000000000000000",
+    feeToken: "0x0000000000000000000000000000000000000000"
   }) {
     this.publicClient = publicClient;
     this.walletClient = walletClient;
@@ -140,10 +141,10 @@ var ContractClient = class {
       throw new SDKError("Invalid Enclave contract address", "INVALID_ADDRESS");
     }
     if (!isValidAddress(addresses.ciphernodeRegistry)) {
-      throw new SDKError(
-        "Invalid CiphernodeRegistry contract address",
-        "INVALID_ADDRESS"
-      );
+      throw new SDKError("Invalid CiphernodeRegistry contract address", "INVALID_ADDRESS");
+    }
+    if (!isValidAddress(addresses.feeToken)) {
+      throw new SDKError("Invalid FeeToken contract address", "INVALID_ADDRESS");
     }
   }
   contractInfo = null;
@@ -160,25 +161,52 @@ var ContractClient = class {
         ciphernodeRegistry: {
           address: this.addresses.ciphernodeRegistry,
           abi: CiphernodeRegistryOwnable__factory.abi
+        },
+        feeToken: {
+          address: this.addresses.feeToken,
+          abi: EnclaveToken__factory.abi
         }
       };
     } catch (error) {
-      throw new SDKError(
-        `Failed to initialize contracts: ${error}`,
-        "INITIALIZATION_FAILED"
-      );
+      throw new SDKError(`Failed to initialize contracts: ${error}`, "INITIALIZATION_FAILED");
+    }
+  }
+  /**
+   * Approve the fee token for the Enclave
+   * approve(address spender, uint256 amount)
+   */
+  async approveFeeToken(amount) {
+    if (!this.walletClient) {
+      throw new SDKError("Wallet client required for write operations", "NO_WALLET");
+    }
+    if (!this.contractInfo) {
+      await this.initialize();
+    }
+    try {
+      const account = this.walletClient.account;
+      if (!account) {
+        throw new SDKError("No account connected", "NO_ACCOUNT");
+      }
+      const { request } = await this.publicClient.simulateContract({
+        address: this.addresses.feeToken,
+        abi: EnclaveToken__factory.abi,
+        functionName: "approve",
+        args: [this.addresses.enclave, amount],
+        account
+      });
+      const hash = await this.walletClient.writeContract(request);
+      return hash;
+    } catch (error) {
+      throw new SDKError(`Failed to approve fee token: ${error}`, "APPROVE_FEE_TOKEN_FAILED");
     }
   }
   /**
    * 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)
    */
-  async requestE3(filter, threshold, startWindow, duration, e3Program, e3ProgramParams, computeProviderParams, value, gasLimit) {
+  async requestE3(threshold, startWindow, duration, e3Program, e3ProgramParams, computeProviderParams, customParams, gasLimit) {
     if (!this.walletClient) {
-      throw new SDKError(
-        "Wallet client required for write operations",
-        "NO_WALLET"
-      );
+      throw new SDKError("Wallet client required for write operations", "NO_WALLET");
     }
     if (!this.contractInfo) {
       await this.initialize();
@@ -192,17 +220,18 @@ var ContractClient = class {
         address: this.addresses.enclave,
         abi: Enclave__factory.abi,
         functionName: "request",
-        args: [{
-          filter,
-          threshold,
-          startWindow,
-          duration,
-          e3Program,
-          e3ProgramParams,
-          computeProviderParams
-        }],
+        args: [
+          {
+            threshold,
+            startWindow,
+            duration,
+            e3Program,
+            e3ProgramParams,
+            computeProviderParams,
+            customParams: customParams || "0x"
+          }
+        ],
         account,
-        value: value || BigInt(0),
         gas: gasLimit
       });
       const hash = await this.walletClient.writeContract(request);
@@ -217,10 +246,7 @@ var ContractClient = class {
    */
   async activateE3(e3Id, publicKey, gasLimit) {
     if (!this.walletClient) {
-      throw new SDKError(
-        "Wallet client required for write operations",
-        "NO_WALLET"
-      );
+      throw new SDKError("Wallet client required for write operations", "NO_WALLET");
     }
     if (!this.contractInfo) {
       await this.initialize();
@@ -241,10 +267,7 @@ var ContractClient = class {
       const hash = await this.walletClient.writeContract(request);
       return hash;
     } catch (error) {
-      throw new SDKError(
-        `Failed to activate E3: ${error}`,
-        "ACTIVATE_E3_FAILED"
-      );
+      throw new SDKError(`Failed to activate E3: ${error}`, "ACTIVATE_E3_FAILED");
     }
   }
   /**
@@ -253,10 +276,7 @@ var ContractClient = class {
    */
   async publishInput(e3Id, data, gasLimit) {
     if (!this.walletClient) {
-      throw new SDKError(
-        "Wallet client required for write operations",
-        "NO_WALLET"
-      );
+      throw new SDKError("Wallet client required for write operations", "NO_WALLET");
     }
     if (!this.contractInfo) {
       await this.initialize();
@@ -277,10 +297,7 @@ var ContractClient = class {
       const hash = await this.walletClient.writeContract(request);
       return hash;
     } catch (error) {
-      throw new SDKError(
-        `Failed to publish input: ${error}`,
-        "PUBLISH_INPUT_FAILED"
-      );
+      throw new SDKError(`Failed to publish input: ${error}`, "PUBLISH_INPUT_FAILED");
     }
   }
   /**
@@ -289,10 +306,7 @@ var ContractClient = class {
    */
   async publishCiphertextOutput(e3Id, ciphertextOutput, proof, gasLimit) {
     if (!this.walletClient) {
-      throw new SDKError(
-        "Wallet client required for write operations",
-        "NO_WALLET"
-      );
+      throw new SDKError("Wallet client required for write operations", "NO_WALLET");
     }
     if (!this.contractInfo) {
       await this.initialize();
@@ -313,10 +327,7 @@ var ContractClient = class {
       const hash = await this.walletClient.writeContract(request);
       return hash;
     } catch (error) {
-      throw new SDKError(
-        `Failed to publish ciphertext output: ${error}`,
-        "PUBLISH_CIPHERTEXT_OUTPUT_FAILED"
-      );
+      throw new SDKError(`Failed to publish ciphertext output: ${error}`, "PUBLISH_CIPHERTEXT_OUTPUT_FAILED");
     }
   }
   /**
@@ -342,7 +353,7 @@ var ContractClient = class {
   /**
    * Get the public key for an E3 computation
    * Based on the contract: committeePublicKey(uint256 e3Id) returns (bytes32 publicKeyHash)
-   * @param e3Id 
+   * @param e3Id
    * @returns The public key
    */
   async getE3PublicKey(e3Id) {
@@ -366,10 +377,7 @@ var ContractClient = class {
    */
   async estimateGas(functionName, args, contractAddress, abi, value) {
     if (!this.walletClient) {
-      throw new SDKError(
-        "Wallet client required for gas estimation",
-        "NO_WALLET"
-      );
+      throw new SDKError("Wallet client required for gas estimation", "NO_WALLET");
     }
     try {
       const account = this.walletClient.account;
@@ -387,10 +395,7 @@ var ContractClient = class {
       const gas = await this.publicClient.estimateContractGas(estimateParams);
       return gas;
     } catch (error) {
-      throw new SDKError(
-        `Failed to estimate gas: ${error}`,
-        "GAS_ESTIMATION_FAILED"
-      );
+      throw new SDKError(`Failed to estimate gas: ${error}`, "GAS_ESTIMATION_FAILED");
     }
   }
   /**
@@ -404,10 +409,7 @@ var ContractClient = class {
       });
       return receipt;
     } catch (error) {
-      throw new SDKError(
-        `Failed to wait for transaction: ${error}`,
-        "TRANSACTION_WAIT_FAILED"
-      );
+      throw new SDKError(`Failed to wait for transaction: ${error}`, "TRANSACTION_WAIT_FAILED");
     }
   }
 };
@@ -465,10 +467,7 @@ var EventListener = class {
         });
         this.activeWatchers.set(watcherKey, unwatch);
       } catch (error) {
-        throw new SDKError(
-          `Failed to watch contract event ${eventType} on ${address}: ${error}`,
-          "WATCH_EVENT_FAILED"
-        );
+        throw new SDKError(`Failed to watch contract event ${eventType} on ${address}: ${error}`, "WATCH_EVENT_FAILED");
       }
     }
   }
@@ -489,10 +488,7 @@ var EventListener = class {
         });
         this.activeWatchers.set(watcherKey, unwatch);
       } catch (error) {
-        throw new SDKError(
-          `Failed to watch logs for address ${address}: ${error}`,
-          "WATCH_LOGS_FAILED"
-        );
+        throw new SDKError(`Failed to watch logs for address ${address}: ${error}`, "WATCH_LOGS_FAILED");
       }
     }
   }
@@ -507,10 +503,7 @@ var EventListener = class {
       void this.pollForEvents();
     } catch (error) {
       this.isPolling = false;
-      throw new SDKError(
-        `Failed to start polling: ${error}`,
-        "POLLING_START_FAILED"
-      );
+      throw new SDKError(`Failed to start polling: ${error}`, "POLLING_START_FAILED");
     }
   }
   /**
@@ -533,10 +526,7 @@ var EventListener = class {
       });
       return logs;
     } catch (error) {
-      throw new SDKError(
-        `Failed to get historical events: ${error}`,
-        "HISTORICAL_EVENTS_FAILED"
-      );
+      throw new SDKError(`Failed to get historical events: ${error}`, "HISTORICAL_EVENTS_FAILED");
     }
   }
   /**
@@ -619,7 +609,6 @@ var EventListener = class {
 var EnclaveEventType = /* @__PURE__ */ ((EnclaveEventType2) => {
   EnclaveEventType2["E3_REQUESTED"] = "E3Requested";
   EnclaveEventType2["E3_ACTIVATED"] = "E3Activated";
-  EnclaveEventType2["INPUT_PUBLISHED"] = "InputPublished";
   EnclaveEventType2["CIPHERTEXT_OUTPUT_PUBLISHED"] = "CiphertextOutputPublished";
   EnclaveEventType2["PLAINTEXT_OUTPUT_PUBLISHED"] = "PlaintextOutputPublished";
   EnclaveEventType2["E3_PROGRAM_ENABLED"] = "E3ProgramEnabled";
@@ -636,6 +625,7 @@ var EnclaveEventType = /* @__PURE__ */ ((EnclaveEventType2) => {
 var RegistryEventType = /* @__PURE__ */ ((RegistryEventType2) => {
   RegistryEventType2["COMMITTEE_REQUESTED"] = "CommitteeRequested";
   RegistryEventType2["COMMITTEE_PUBLISHED"] = "CommitteePublished";
+  RegistryEventType2["COMMITTEE_FINALIZED"] = "CommitteeFinalized";
   RegistryEventType2["ENCLAVE_SET"] = "EnclaveSet";
   RegistryEventType2["OWNERSHIP_TRANSFERRED"] = "OwnershipTransferred";
   RegistryEventType2["INITIALIZED"] = "Initialized";
@@ -643,28 +633,68 @@ var RegistryEventType = /* @__PURE__ */ ((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
-  */
+   * Recommended parameters for BFV protocol
+   * - Degree: 2048
+   * - Plaintext modulus: 1032193
+   * - Moduli:0x3FFFFFFF000001
+   */
   BFV_NORMAL: {
     degree: 2048,
     plaintextModulus: 1032193n,
-    moduli: 0x3FFFFFFF000001n
+    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"
   }
 };
 
 // src/enclave-sdk.ts
-import { bfv_encrypt_number, bfv_verifiable_encrypt_number } from "@enclave-e3/wasm";
+import {
+  bfv_encrypt_number,
+  bfv_encrypt_vector,
+  bfv_verifiable_encrypt_number,
+  bfv_verifiable_encrypt_vector,
+  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
@@ -683,29 +713,14 @@ var generateProof = async (circuitInputs, circuit) => {
   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: {
-    //     q_mod_t: circuitInputs.params.q_mod_t,
-    //     pk_bounds: circuitInputs.params.pk_bounds,
-    //     e_bound: circuitInputs.params.e_bound,
-    //     u_bound: circuitInputs.params.u_bound,
-    //     r1_low_bounds: circuitInputs.params.r1_low_bounds,
-    //     r1_up_bounds: circuitInputs.params.r1_up_bounds,
-    //     r2_bounds: circuitInputs.params.r2_bounds,
-    //     p1_bounds: circuitInputs.params.p1_bounds,
-    //     p2_bounds: circuitInputs.params.p2_bounds,
-    //     k1_low_bound: circuitInputs.params.k1_low_bound,
-    //     k1_up_bound: circuitInputs.params.k1_up_bound,
-    //     qis: circuitInputs.params.qis,
-    //     k0is: circuitInputs.params.k0is,
-    //     size: circuitInputs.params.size,
-    //     tag: circuitInputs.params.tag,
-    // },
+    params: defaultParams,
     pk0is: pk0is_poly,
     pk1is: pk1is_poly,
     ct0is: ct0is_poly,
@@ -713,17 +728,19 @@ var generateProof = async (circuitInputs, circuit) => {
     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
   });
-  return await backend.generateProof(witness, { keccak: true });
+  return await backend.generateProof(witness, { keccakZK: true });
 };
 
 // src/enclave-sdk.ts
 var EnclaveSDK = class _EnclaveSDK {
+  // TODO: use zod for config validation
   constructor(config) {
     this.config = config;
     if (!config.publicClient) {
@@ -733,29 +750,21 @@ var EnclaveSDK = class _EnclaveSDK {
       throw new SDKError("Invalid Enclave contract address", "INVALID_ADDRESS");
     }
     if (!isValidAddress(config.contracts.ciphernodeRegistry)) {
-      throw new SDKError(
-        "Invalid CiphernodeRegistry contract address",
-        "INVALID_ADDRESS"
-      );
+      throw new SDKError("Invalid CiphernodeRegistry contract address", "INVALID_ADDRESS");
+    }
+    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
-    );
+    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");
+    }
     this.protocol = config.protocol;
     if (config.protocolParams) {
       this.protocolParams = config.protocolParams;
-    } else {
-      switch (this.protocol) {
-        case "BFV" /* BFV */:
-          this.protocolParams = BfvProtocolParams.BFV_NORMAL;
-          break;
-        default:
-          throw new Error("Protocol not supported");
-      }
     }
+    this.publicClient = config.publicClient;
   }
   static chains = {
     1: mainnet,
@@ -768,6 +777,7 @@ var EnclaveSDK = class _EnclaveSDK {
   initialized = false;
   protocol;
   protocolParams;
+  publicClient;
   /**
    * Initialize the SDK
    */
@@ -778,10 +788,37 @@ var EnclaveSDK = class _EnclaveSDK {
       await this.contractClient.initialize();
       this.initialized = true;
     } catch (error) {
-      throw new SDKError(
-        `Failed to initialize SDK: ${error}`,
-        "SDK_INITIALIZATION_FAILED"
-      );
+      throw new SDKError(`Failed to initialize SDK: ${error}`, "SDK_INITIALIZATION_FAILED");
+    }
+  }
+  /**
+   * Get the public client used by the SDK
+   * @returns The public client
+   */
+  getPublicClient = () => {
+    return this.publicClient;
+  };
+  async getBfvParamsSet(name) {
+    await initializeWasm();
+    let params = get_bfv_params(name);
+    return {
+      degree: Number(params.degree),
+      // degree is returned as a bigint from wasm
+      plaintextModulus: params.plaintext_modulus,
+      moduli: params.moduli,
+      error1Variance: params.error1_variance
+    };
+  }
+  async getProtocolParams() {
+    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");
     }
   }
   /**
@@ -792,18 +829,54 @@ var EnclaveSDK = class _EnclaveSDK {
    */
   async encryptNumber(data, publicKey) {
     await initializeWasm();
-    switch (this.protocol) {
-      case "BFV" /* BFV */:
-        return bfv_encrypt_number(
-          data,
-          publicKey,
-          this.protocolParams.degree,
-          this.protocolParams.plaintextModulus,
-          this.protocolParams.moduli
-        );
-      default:
-        throw new Error("Protocol not supported");
-    }
+    const protocolParams = await this.getProtocolParams();
+    return bfv_encrypt_number(
+      data,
+      publicKey,
+      protocolParams.degree,
+      protocolParams.plaintextModulus,
+      BigUint64Array.from(protocolParams.moduli)
+    );
+  }
+  /**
+   * 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
+   */
+  async encryptVector(data, publicKey) {
+    await initializeWasm();
+    const protocolParams = await this.getProtocolParams();
+    return bfv_encrypt_vector(
+      data,
+      publicKey,
+      protocolParams.degree,
+      protocolParams.plaintextModulus,
+      BigUint64Array.from(protocolParams.moduli)
+    );
+  }
+  /**
+   * 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
+   */
+  async encryptNumberAndGenInputs(data, publicKey) {
+    await initializeWasm();
+    const protocolParams = await this.getProtocolParams();
+    const [encryptedData, circuitInputs] = bfv_verifiable_encrypt_number(
+      data,
+      publicKey,
+      protocolParams.degree,
+      protocolParams.plaintextModulus,
+      BigUint64Array.from(protocolParams.moduli)
+    );
+    const publicInputs = JSON.parse(circuitInputs);
+    return {
+      encryptedData,
+      publicInputs
+    };
   }
   /**
    * Encrypt a number using the configured protocol and generate a zk-SNARK proof using Greco
@@ -813,25 +886,61 @@ 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 proof = await generateProof(publicInputs, circuit);
+    return {
+      encryptedData,
+      proof
+    };
+  }
+  /**
+   * 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
+   */
+  async encryptVectorAndGenInputs(data, publicKey) {
     await initializeWasm();
-    switch (this.protocol) {
-      case "BFV" /* BFV */:
-        const [encryptedVote, circuitInputs] = bfv_verifiable_encrypt_number(
-          data,
-          publicKey,
-          this.protocolParams.degree,
-          this.protocolParams.plaintextModulus,
-          this.protocolParams.moduli
-        );
-        const inputs = JSON.parse(circuitInputs);
-        const proof = await generateProof(inputs, circuit);
-        return {
-          encryptedVote,
-          proof
-        };
-      default:
-        throw new Error("Protocol not supported");
+    const protocolParams = await this.getProtocolParams();
+    const [encryptedData, circuitInputs] = bfv_verifiable_encrypt_vector(
+      data,
+      publicKey,
+      protocolParams.degree,
+      protocolParams.plaintextModulus,
+      BigUint64Array.from(protocolParams.moduli)
+    );
+    const publicInputs = JSON.parse(circuitInputs);
+    return {
+      encryptedData,
+      publicInputs
+    };
+  }
+  /**
+   * 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
+   */
+  async encryptVectorAndGenProof(data, publicKey, circuit) {
+    const { publicInputs, encryptedData } = await this.encryptVectorAndGenInputs(data, publicKey);
+    const proof = await generateProof(publicInputs, circuit);
+    return {
+      encryptedData,
+      proof
+    };
+  }
+  /**
+   * Approve the fee token for the Enclave
+   * @param amount - The amount to approve
+   * @returns The approval transaction hash
+   */
+  async approveFeeToken(amount) {
+    console.log(">>> APPROVE FEE TOKEN");
+    if (!this.initialized) {
+      await this.initialize();
     }
+    return this.contractClient.approveFeeToken(amount);
   }
   /**
    * Request a new E3 computation
@@ -842,14 +951,13 @@ var EnclaveSDK = class _EnclaveSDK {
       await this.initialize();
     }
     return this.contractClient.requestE3(
-      params.filter,
       params.threshold,
       params.startWindow,
       params.duration,
       params.e3Program,
       params.e3ProgramParams,
       params.computeProviderParams,
-      params.value,
+      params.customParams,
       params.gasLimit
     );
   }
@@ -889,12 +997,7 @@ var EnclaveSDK = class _EnclaveSDK {
     if (!this.initialized) {
       await this.initialize();
     }
-    return this.contractClient.publishCiphertextOutput(
-      e3Id,
-      ciphertextOutput,
-      proof,
-      gasLimit
-    );
+    return this.contractClient.publishCiphertextOutput(e3Id, ciphertextOutput, proof, gasLimit);
   }
   /**
    * Get E3 information
@@ -909,17 +1012,10 @@ var EnclaveSDK = class _EnclaveSDK {
    * Unified Event Listening - Listen to any Enclave or Registry event
    */
   onEnclaveEvent(eventType, callback) {
-    const isEnclaveEvent = Object.values(EnclaveEventType).includes(
-      eventType
-    );
+    const isEnclaveEvent = Object.values(EnclaveEventType).includes(eventType);
     const contractAddress = isEnclaveEvent ? this.config.contracts.enclave : this.config.contracts.ciphernodeRegistry;
     const abi = isEnclaveEvent ? Enclave__factory2.abi : CiphernodeRegistryOwnable__factory2.abi;
-    void this.eventListener.watchContractEvent(
-      contractAddress,
-      eventType,
-      abi,
-      callback
-    );
+    void this.eventListener.watchContractEvent(contractAddress, eventType, abi, callback);
   }
   /**
    * Remove event listener
@@ -944,18 +1040,10 @@ var EnclaveSDK = class _EnclaveSDK {
    * Get historical events
    */
   async getHistoricalEvents(eventType, fromBlock, toBlock) {
-    const isEnclaveEvent = Object.values(EnclaveEventType).includes(
-      eventType
-    );
+    const isEnclaveEvent = Object.values(EnclaveEventType).includes(eventType);
     const contractAddress = isEnclaveEvent ? this.config.contracts.enclave : this.config.contracts.ciphernodeRegistry;
     const abi = isEnclaveEvent ? Enclave__factory2.abi : CiphernodeRegistryOwnable__factory2.abi;
-    return this.eventListener.getHistoricalEvents(
-      contractAddress,
-      eventType,
-      abi,
-      fromBlock,
-      toBlock
-    );
+    return this.eventListener.getHistoricalEvents(contractAddress, eventType, abi, fromBlock, toBlock);
   }
   /**
    * Start polling for events
@@ -976,13 +1064,7 @@ var EnclaveSDK = class _EnclaveSDK {
    * Estimate gas for a transaction
    */
   async estimateGas(functionName, args, contractAddress, abi, value) {
-    return this.contractClient.estimateGas(
-      functionName,
-      args,
-      contractAddress,
-      abi,
-      value
-    );
+    return this.contractClient.estimateGas(functionName, args, contractAddress, abi, value);
   }
   /**
    * Wait for transaction confirmation
@@ -1017,11 +1099,7 @@ var EnclaveSDK = class _EnclaveSDK {
     if (newConfig.chainId) {
       this.config.chainId = newConfig.chainId;
     }
-    this.contractClient = new ContractClient(
-      this.config.publicClient,
-      this.config.walletClient,
-      this.config.contracts
-    );
+    this.contractClient = new ContractClient(this.config.publicClient, this.config.walletClient, this.config.contracts);
     this.initialized = false;
   }
   static create(options) {
@@ -1067,9 +1145,12 @@ export {
   RegistryEventType,
   SDKError,
   calculateStartWindow,
+  convertToPolynomial,
+  convertToPolynomialArray,
   decodePlaintextOutput,
   encodeBfvParams,
   encodeComputeProviderParams,
+  encodeCustomParams,
   formatBigInt,
   formatEventName,
   generateEventId,