@enclave-e3/sdk 0.1.7 → 0.1.9

package/README.md

@@ -217,7 +217,7 @@ await sdk.requestE3({
 });
 
 // Activate an E3 computation
-await sdk.activateE3(e3Id: bigint, publicKey: `0x${string}`, gasLimit?: bigint);
+await sdk.activateE3(e3Id: bigint, gasLimit?: bigint);
 
 // Publish input data
 await sdk.publishInput(e3Id: bigint, data: `0x${string}`, gasLimit?: bigint);

package/dist/index.cjs

@@ -30,20 +30,16 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/index.ts
 var index_exports = {};
 __export(index_exports, {
-  BFV_PARAMS_SET: () => BFV_PARAMS_SET,
-  BfvProtocolParams: () => BfvProtocolParams,
   ContractClient: () => ContractClient,
   DEFAULT_COMPUTE_PROVIDER_PARAMS: () => DEFAULT_COMPUTE_PROVIDER_PARAMS,
   DEFAULT_E3_CONFIG: () => DEFAULT_E3_CONFIG,
   EnclaveEventType: () => EnclaveEventType,
   EnclaveSDK: () => EnclaveSDK,
   EventListener: () => EventListener,
-  FheProtocol: () => FheProtocol,
   RegistryEventType: () => RegistryEventType,
   SDKError: () => SDKError,
+  ThresholdBfvParamsPresetNames: () => ThresholdBfvParamsPresetNames,
   calculateStartWindow: () => calculateStartWindow,
-  convertToPolynomial: () => convertToPolynomial,
-  convertToPolynomialArray: () => convertToPolynomialArray,
   decodePlaintextOutput: () => decodePlaintextOutput,
   encodeBfvParams: () => encodeBfvParams,
   encodeComputeProviderParams: () => encodeComputeProviderParams,
@@ -107,14 +103,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,
@@ -130,7 +118,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 (0, import_viem.encodeAbiParameters)(
     [
       {
@@ -147,9 +142,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
       }
     ]
   );
@@ -305,9 +300,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");
     }
@@ -323,7 +318,7 @@ var ContractClient = class {
         address: this.addresses.enclave,
         abi: import_types.Enclave__factory.abi,
         functionName: "activate",
-        args: [e3Id, publicKey],
+        args: [e3Id],
         account,
         gas: gasLimit
       });
@@ -694,37 +689,10 @@ 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
 var import_wasm = require("@enclave-e3/wasm");
@@ -732,66 +700,10 @@ var import_wasm = require("@enclave-e3/wasm");
 // src/greco.ts
 var import_bb = require("@aztec/bb.js");
 var import_noir_js = require("@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 import_noir_js.Noir(circuit);
   const backend = new import_bb.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 });
 };
 
@@ -812,15 +724,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 = {
@@ -832,8 +747,7 @@ var EnclaveSDK = class _EnclaveSDK {
   eventListener;
   contractClient;
   initialized = false;
-  protocol;
-  protocolParams;
+  thresholdBfvParamsPresetName;
   publicClient;
   /**
    * Initialize the SDK
@@ -855,9 +769,9 @@ var EnclaveSDK = class _EnclaveSDK {
   getPublicClient = () => {
     return this.publicClient;
   };
-  async getBfvParamsSet(name) {
+  async getThresholdBfvParamsSet() {
     await (0, import_init.default)();
-    let params = (0, import_wasm.get_bfv_params)(name);
+    let params = (0, import_wasm.get_bfv_params)(this.thresholdBfvParamsPresetName);
     return {
       degree: Number(params.degree),
       // degree is returned as a bigint from wasm
@@ -866,17 +780,20 @@ var EnclaveSDK = class _EnclaveSDK {
       error1Variance: params.error1_variance
     };
   }
-  async getProtocolParams() {
+  async generatePublicKey() {
     await (0, import_init.default)();
-    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 (0, import_wasm.generate_public_key)(protocolParams.degree, protocolParams.plaintextModulus, BigUint64Array.from(protocolParams.moduli));
+  }
+  async computePublicKeyCommitment(publicKey) {
+    await (0, import_init.default)();
+    const protocolParams = await this.getThresholdBfvParamsSet();
+    return (0, import_wasm.compute_pk_commitment)(
+      publicKey,
+      protocolParams.degree,
+      protocolParams.plaintextModulus,
+      BigUint64Array.from(protocolParams.moduli)
+    );
   }
   /**
    * Encrypt a number using the configured protocol
@@ -886,7 +803,7 @@ var EnclaveSDK = class _EnclaveSDK {
    */
   async encryptNumber(data, publicKey) {
     await (0, import_init.default)();
-    const protocolParams = await this.getProtocolParams();
+    const protocolParams = await this.getThresholdBfvParamsSet();
     return (0, import_wasm.bfv_encrypt_number)(
       data,
       publicKey,
@@ -903,7 +820,7 @@ var EnclaveSDK = class _EnclaveSDK {
    */
   async encryptVector(data, publicKey) {
     await (0, import_init.default)();
-    const protocolParams = await this.getProtocolParams();
+    const protocolParams = await this.getThresholdBfvParamsSet();
     return (0, import_wasm.bfv_encrypt_vector)(
       data,
       publicKey,
@@ -921,7 +838,7 @@ var EnclaveSDK = class _EnclaveSDK {
    */
   async encryptNumberAndGenInputs(data, publicKey) {
     await (0, import_init.default)();
-    const protocolParams = await this.getProtocolParams();
+    const protocolParams = await this.getThresholdBfvParamsSet();
     const [encryptedData, circuitInputs] = (0, import_wasm.bfv_verifiable_encrypt_number)(
       data,
       publicKey,
@@ -929,10 +846,9 @@ var EnclaveSDK = class _EnclaveSDK {
       protocolParams.plaintextModulus,
       BigUint64Array.from(protocolParams.moduli)
     );
-    const publicInputs = JSON.parse(circuitInputs);
     return {
       encryptedData,
-      publicInputs
+      circuitInputs: JSON.parse(circuitInputs)
     };
   }
   /**
@@ -943,7 +859,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,
@@ -958,7 +874,7 @@ var EnclaveSDK = class _EnclaveSDK {
    */
   async encryptVectorAndGenInputs(data, publicKey) {
     await (0, import_init.default)();
-    const protocolParams = await this.getProtocolParams();
+    const protocolParams = await this.getThresholdBfvParamsSet();
     const [encryptedData, circuitInputs] = (0, import_wasm.bfv_verifiable_encrypt_vector)(
       data,
       publicKey,
@@ -966,10 +882,9 @@ var EnclaveSDK = class _EnclaveSDK {
       protocolParams.plaintextModulus,
       BigUint64Array.from(protocolParams.moduli)
     );
-    const publicInputs = JSON.parse(circuitInputs);
     return {
       encryptedData,
-      publicInputs
+      circuitInputs: JSON.parse(circuitInputs)
     };
   }
   /**
@@ -980,7 +895,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,
@@ -1032,11 +947,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
@@ -1184,27 +1099,22 @@ var EnclaveSDK = class _EnclaveSDK {
       walletClient,
       contracts: options.contracts,
       chainId: options.chainId,
-      protocol: options.protocol,
-      protocolParams: options.protocolParams
+      thresholdBfvParamsPresetName: options.thresholdBfvParamsPresetName
     });
   }
 };
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  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,