@enclave-e3/sdk 0.0.7-test

package/dist/index.js

@@ -0,0 +1,1053 @@
+// src/enclave-sdk.ts
+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";
+
+// src/contract-client.ts
+import {
+  CiphernodeRegistryOwnable__factory,
+  Enclave__factory
+} from "@enclave-e3/contracts/types";
+
+// src/utils.ts
+import { encodeAbiParameters } from "viem";
+var SDKError = class extends Error {
+  constructor(message, code) {
+    super(message);
+    this.code = code;
+    this.name = "SDKError";
+  }
+};
+function isValidAddress(address) {
+  return /^0x[a-fA-F0-9]{40}$/.test(address);
+}
+function isValidHash(hash) {
+  return /^0x[a-fA-F0-9]{64}$/.test(hash);
+}
+function formatEventName(contractName, eventName) {
+  return `${contractName}.${eventName}`;
+}
+function parseEventData(log) {
+  return log.data;
+}
+var sleep = (ms) => {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+};
+function formatBigInt(value) {
+  return value.toString();
+}
+function parseBigInt(value) {
+  return BigInt(value);
+}
+function generateEventId(log) {
+  return `${log.blockHash}-${log.logIndex}`;
+}
+function getCurrentTimestamp() {
+  return Math.floor(Date.now() / 1e3);
+}
+var BFV_PARAMS_SET = {
+  degree: 2048,
+  plaintext_modulus: 1032193,
+  moduli: [0x3fffffff000001n]
+  // BigInt for the modulus
+};
+var DEFAULT_COMPUTE_PROVIDER_PARAMS = {
+  name: "risc0",
+  parallel: false,
+  batch_size: 2
+};
+var DEFAULT_E3_CONFIG = {
+  threshold_min: 2,
+  threshold_max: 3,
+  window_size: 120,
+  // 2 minutes in seconds
+  duration: 1800,
+  // 30 minutes in seconds
+  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) {
+  return encodeAbiParameters(
+    [
+      {
+        name: "bfvParams",
+        type: "tuple",
+        components: [
+          { name: "degree", type: "uint256" },
+          { name: "plaintext_modulus", type: "uint256" },
+          { name: "moduli", type: "uint256[]" }
+        ]
+      }
+    ],
+    [
+      {
+        degree: BigInt(degree),
+        plaintext_modulus: BigInt(plaintext_modulus),
+        moduli: [...moduli]
+      }
+    ]
+  );
+}
+function encodeComputeProviderParams(params) {
+  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 calculateStartWindow(windowSize = DEFAULT_E3_CONFIG.window_size) {
+  const now = getCurrentTimestamp();
+  return [BigInt(now), BigInt(now + windowSize)];
+}
+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)) || []
+    );
+    if (bytes.length < 8) {
+      console.warn("Plaintext output too short for u64 decoding");
+      return null;
+    }
+    const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+    const result = view.getBigUint64(0, true);
+    return Number(result);
+  } catch (error) {
+    console.error("Failed to decode plaintext output:", error);
+    return null;
+  }
+}
+
+// src/contract-client.ts
+var ContractClient = class {
+  constructor(publicClient, walletClient, addresses = {
+    enclave: "0x0000000000000000000000000000000000000000",
+    ciphernodeRegistry: "0x0000000000000000000000000000000000000000"
+  }) {
+    this.publicClient = publicClient;
+    this.walletClient = walletClient;
+    this.addresses = addresses;
+    if (!isValidAddress(addresses.enclave)) {
+      throw new SDKError("Invalid Enclave contract address", "INVALID_ADDRESS");
+    }
+    if (!isValidAddress(addresses.ciphernodeRegistry)) {
+      throw new SDKError(
+        "Invalid CiphernodeRegistry contract address",
+        "INVALID_ADDRESS"
+      );
+    }
+  }
+  contractInfo = null;
+  /**
+   * Initialize contract instances
+   */
+  async initialize() {
+    try {
+      this.contractInfo = {
+        enclave: {
+          address: this.addresses.enclave,
+          abi: Enclave__factory.abi
+        },
+        ciphernodeRegistry: {
+          address: this.addresses.ciphernodeRegistry,
+          abi: CiphernodeRegistryOwnable__factory.abi
+        }
+      };
+    } catch (error) {
+      throw new SDKError(
+        `Failed to initialize contracts: ${error}`,
+        "INITIALIZATION_FAILED"
+      );
+    }
+  }
+  /**
+   * Request a new E3 computation
+   * request(address filter, uint32[2] threshold, uint256[2] startWindow, uint256 duration, IE3Program e3Program, bytes e3ProgramParams, bytes computeProviderParams)
+   */
+  async requestE3(filter, threshold, startWindow, duration, e3Program, e3ProgramParams, computeProviderParams, value, gasLimit) {
+    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.enclave,
+        abi: Enclave__factory.abi,
+        functionName: "request",
+        args: [
+          {
+            filter,
+            threshold,
+            startWindow,
+            duration,
+            e3Program,
+            e3ProgramParams,
+            computeProviderParams
+          }
+        ],
+        account,
+        value: value || BigInt(0),
+        gas: gasLimit
+      });
+      const hash = await this.walletClient.writeContract(request);
+      return hash;
+    } catch (error) {
+      throw new SDKError(`Failed to request E3: ${error}`, "REQUEST_E3_FAILED");
+    }
+  }
+  /**
+   * Activate an E3 computation
+   * activate(uint256 e3Id, bytes memory publicKey)
+   */
+  async activateE3(e3Id, publicKey, gasLimit) {
+    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.enclave,
+        abi: Enclave__factory.abi,
+        functionName: "activate",
+        args: [e3Id, publicKey],
+        account,
+        gas: gasLimit
+      });
+      const hash = await this.walletClient.writeContract(request);
+      return hash;
+    } catch (error) {
+      throw new SDKError(
+        `Failed to activate E3: ${error}`,
+        "ACTIVATE_E3_FAILED"
+      );
+    }
+  }
+  /**
+   * Publish input for an E3 computation
+   * publishInput(uint256 e3Id, bytes memory data)
+   */
+  async publishInput(e3Id, data, gasLimit) {
+    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.enclave,
+        abi: Enclave__factory.abi,
+        functionName: "publishInput",
+        args: [e3Id, data],
+        account,
+        gas: gasLimit
+      });
+      const hash = await this.walletClient.writeContract(request);
+      return hash;
+    } catch (error) {
+      throw new SDKError(
+        `Failed to publish input: ${error}`,
+        "PUBLISH_INPUT_FAILED"
+      );
+    }
+  }
+  /**
+   * Publish ciphertext output for an E3 computation
+   * publishCiphertextOutput(uint256 e3Id, bytes memory ciphertextOutput, bytes memory proof)
+   */
+  async publishCiphertextOutput(e3Id, ciphertextOutput, proof, gasLimit) {
+    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.enclave,
+        abi: Enclave__factory.abi,
+        functionName: "publishCiphertextOutput",
+        args: [e3Id, ciphertextOutput, proof],
+        account,
+        gas: gasLimit
+      });
+      const hash = await this.walletClient.writeContract(request);
+      return hash;
+    } catch (error) {
+      throw new SDKError(
+        `Failed to publish ciphertext output: ${error}`,
+        "PUBLISH_CIPHERTEXT_OUTPUT_FAILED"
+      );
+    }
+  }
+  /**
+   * Get E3 information
+   * Based on the contract: getE3(uint256 e3Id) returns (E3 memory e3)
+   */
+  async getE3(e3Id) {
+    if (!this.contractInfo) {
+      await this.initialize();
+    }
+    try {
+      const result = await this.publicClient.readContract({
+        address: this.addresses.enclave,
+        abi: Enclave__factory.abi,
+        functionName: "getE3",
+        args: [e3Id]
+      });
+      return result;
+    } catch (error) {
+      throw new SDKError(`Failed to get E3: ${error}`, "GET_E3_FAILED");
+    }
+  }
+  /**
+   * Estimate gas for a transaction
+   */
+  async estimateGas(functionName, args, contractAddress, abi, value) {
+    if (!this.walletClient) {
+      throw new SDKError(
+        "Wallet client required for gas estimation",
+        "NO_WALLET"
+      );
+    }
+    try {
+      const account = this.walletClient.account;
+      if (!account) {
+        throw new SDKError("No account connected", "NO_ACCOUNT");
+      }
+      const estimateParams = {
+        address: contractAddress,
+        abi,
+        functionName,
+        args,
+        account,
+        ...value !== void 0 && { value }
+      };
+      const gas = await this.publicClient.estimateContractGas(estimateParams);
+      return gas;
+    } catch (error) {
+      throw new SDKError(
+        `Failed to estimate gas: ${error}`,
+        "GAS_ESTIMATION_FAILED"
+      );
+    }
+  }
+  /**
+   * Wait for transaction confirmation
+   */
+  async waitForTransaction(hash) {
+    try {
+      const receipt = await this.publicClient.waitForTransactionReceipt({
+        hash,
+        confirmations: 1
+      });
+      return receipt;
+    } catch (error) {
+      throw new SDKError(
+        `Failed to wait for transaction: ${error}`,
+        "TRANSACTION_WAIT_FAILED"
+      );
+    }
+  }
+};
+
+// src/event-listener.ts
+var EventListener = class {
+  constructor(publicClient, config = {}) {
+    this.publicClient = publicClient;
+    this.config = config;
+  }
+  listeners = /* @__PURE__ */ new Map();
+  activeWatchers = /* @__PURE__ */ new Map();
+  isPolling = false;
+  lastBlockNumber = BigInt(0);
+  /**
+   * Listen to specific contract events
+   */
+  async watchContractEvent(address, eventType, abi, callback) {
+    const watcherKey = `${address}:${eventType}`;
+    console.log(`watchContractEvent: ${watcherKey}`);
+    if (!this.listeners.has(eventType)) {
+      this.listeners.set(eventType, /* @__PURE__ */ new Set());
+    }
+    console.log("Added callback");
+    this.listeners.get(eventType).add(callback);
+    const emitter = this;
+    if (!this.activeWatchers.has(watcherKey)) {
+      console.log("Adding active watcher for " + watcherKey);
+      try {
+        const unwatch = this.publicClient.watchContractEvent({
+          address,
+          abi,
+          eventName: eventType,
+          fromBlock: this.config.fromBlock,
+          onLogs(logs) {
+            for (let i = 0; i < logs.length; i++) {
+              const log = logs[i];
+              if (!log) {
+                console.log("warning: Log was falsy when a log was expected!");
+                break;
+              }
+              const event = {
+                type: eventType,
+                data: log.args,
+                log,
+                timestamp: /* @__PURE__ */ new Date(),
+                blockNumber: log.blockNumber ?? BigInt(0),
+                transactionHash: log.transactionHash ?? "0x"
+              };
+              console.log("Created event, now emitting event...");
+              emitter.emit(event);
+              console.log("Event emitted");
+            }
+          }
+        });
+        this.activeWatchers.set(watcherKey, unwatch);
+      } catch (error) {
+        throw new SDKError(
+          `Failed to watch contract event ${eventType} on ${address}: ${error}`,
+          "WATCH_EVENT_FAILED"
+        );
+      }
+    }
+  }
+  /**
+   * Listen to all logs from a specific address
+   */
+  async watchLogs(address, callback) {
+    const watcherKey = `logs:${address}`;
+    if (!this.activeWatchers.has(watcherKey)) {
+      try {
+        const unwatch = this.publicClient.watchEvent({
+          address,
+          onLogs: (logs) => {
+            logs.forEach((log) => {
+              callback(log);
+            });
+          }
+        });
+        this.activeWatchers.set(watcherKey, unwatch);
+      } catch (error) {
+        throw new SDKError(
+          `Failed to watch logs for address ${address}: ${error}`,
+          "WATCH_LOGS_FAILED"
+        );
+      }
+    }
+  }
+  /**
+   * Start polling for historical events
+   */
+  async startPolling() {
+    if (this.isPolling) return;
+    this.isPolling = true;
+    try {
+      this.lastBlockNumber = await this.publicClient.getBlockNumber();
+      void this.pollForEvents();
+    } catch (error) {
+      this.isPolling = false;
+      throw new SDKError(
+        `Failed to start polling: ${error}`,
+        "POLLING_START_FAILED"
+      );
+    }
+  }
+  /**
+   * Stop polling for events
+   */
+  stopPolling() {
+    this.isPolling = false;
+  }
+  /**
+   * Get historical events
+   */
+  async getHistoricalEvents(address, eventType, abi, fromBlock, toBlock) {
+    try {
+      const logs = await this.publicClient.getContractEvents({
+        address,
+        abi,
+        eventName: eventType,
+        fromBlock: fromBlock || this.config.fromBlock,
+        toBlock: toBlock || this.config.toBlock
+      });
+      return logs;
+    } catch (error) {
+      throw new SDKError(
+        `Failed to get historical events: ${error}`,
+        "HISTORICAL_EVENTS_FAILED"
+      );
+    }
+  }
+  /**
+   * SDKEventEmitter implementation
+   */
+  on(eventType, callback) {
+    if (!this.listeners.has(eventType)) {
+      this.listeners.set(eventType, /* @__PURE__ */ new Set());
+    }
+    this.listeners.get(eventType).add(callback);
+  }
+  off(eventType, callback) {
+    const callbacks = this.listeners.get(eventType);
+    if (callbacks) {
+      callbacks.delete(callback);
+      if (callbacks.size === 0) {
+        this.listeners.delete(eventType);
+        const watchersToRemove = [];
+        this.activeWatchers.forEach((unwatch, key) => {
+          if (key.endsWith(`:${eventType}`)) {
+            try {
+              unwatch();
+            } catch (error) {
+              console.error(`Error unwatching event ${eventType}:`, error);
+            }
+            watchersToRemove.push(key);
+          }
+        });
+        watchersToRemove.forEach((key) => this.activeWatchers.delete(key));
+      }
+    }
+  }
+  emit(event) {
+    console.log("emit() called for " + event.type);
+    const callbacks = this.listeners.get(event.type);
+    if (callbacks) {
+      console.log("Have " + callbacks.size + " callbacks");
+      callbacks.forEach((callback) => {
+        console.log("Running callback...");
+        try {
+          void callback(event);
+        } catch (error) {
+          console.error(`Error in event callback for ${event.type}:`, error);
+        }
+      });
+    }
+  }
+  /**
+   * Clean up all listeners and watchers
+   */
+  cleanup() {
+    this.stopPolling();
+    this.activeWatchers.forEach((unwatch) => {
+      try {
+        unwatch();
+      } catch (error) {
+        console.error("Error unwatching during cleanup:", error);
+      }
+    });
+    this.activeWatchers.clear();
+    this.listeners.clear();
+  }
+  async pollForEvents() {
+    while (this.isPolling) {
+      try {
+        const currentBlock = await this.publicClient.getBlockNumber();
+        if (currentBlock > this.lastBlockNumber) {
+          this.lastBlockNumber = currentBlock;
+        }
+        await sleep(this.config.pollingInterval || 5e3);
+      } catch (error) {
+        console.error("Error during polling:", error);
+        await sleep(this.config.pollingInterval || 5e3);
+      }
+    }
+  }
+};
+
+// src/types.ts
+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";
+  EnclaveEventType2["E3_PROGRAM_DISABLED"] = "E3ProgramDisabled";
+  EnclaveEventType2["ENCRYPTION_SCHEME_ENABLED"] = "EncryptionSchemeEnabled";
+  EnclaveEventType2["ENCRYPTION_SCHEME_DISABLED"] = "EncryptionSchemeDisabled";
+  EnclaveEventType2["CIPHERNODE_REGISTRY_SET"] = "CiphernodeRegistrySet";
+  EnclaveEventType2["MAX_DURATION_SET"] = "MaxDurationSet";
+  EnclaveEventType2["ALLOWED_E3_PROGRAMS_PARAMS_SET"] = "AllowedE3ProgramsParamsSet";
+  EnclaveEventType2["OWNERSHIP_TRANSFERRED"] = "OwnershipTransferred";
+  EnclaveEventType2["INITIALIZED"] = "Initialized";
+  return EnclaveEventType2;
+})(EnclaveEventType || {});
+var RegistryEventType = /* @__PURE__ */ ((RegistryEventType2) => {
+  RegistryEventType2["COMMITTEE_REQUESTED"] = "CommitteeRequested";
+  RegistryEventType2["COMMITTEE_PUBLISHED"] = "CommitteePublished";
+  RegistryEventType2["ENCLAVE_SET"] = "EnclaveSet";
+  RegistryEventType2["OWNERSHIP_TRANSFERRED"] = "OwnershipTransferred";
+  RegistryEventType2["INITIALIZED"] = "Initialized";
+  return RegistryEventType2;
+})(RegistryEventType || {});
+var FheProtocol = /* @__PURE__ */ ((FheProtocol2) => {
+  FheProtocol2["BFV"] = "BFV";
+  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
+  }
+};
+
+// src/enclave-sdk.ts
+import { bfv_encrypt_number, bfv_verifiable_encrypt_number } from "@enclave-e3/wasm";
+
+// src/greco.ts
+import { UltraHonkBackend } from "@aztec/bb.js";
+import { Noir } from "@noir-lang/noir_js";
+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 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,
+    // },
+    pk0is: pk0is_poly,
+    pk1is: pk1is_poly,
+    ct0is: ct0is_poly,
+    ct1is: ct1is_poly,
+    u: u_poly,
+    e0: e0_poly,
+    e1: e1_poly,
+    k1: k1_poly,
+    r1is: r1is_poly,
+    r2is: r2is_poly,
+    p1is: p1is_poly,
+    p2is: p2is_poly
+  });
+  return await backend.generateProof(witness, { keccak: true });
+};
+
+// src/enclave-sdk.ts
+var EnclaveSDK = class _EnclaveSDK {
+  constructor(config) {
+    this.config = config;
+    if (!config.publicClient) {
+      throw new SDKError("Public client is required", "MISSING_PUBLIC_CLIENT");
+    }
+    if (!isValidAddress(config.contracts.enclave)) {
+      throw new SDKError("Invalid Enclave contract address", "INVALID_ADDRESS");
+    }
+    if (!isValidAddress(config.contracts.ciphernodeRegistry)) {
+      throw new SDKError(
+        "Invalid CiphernodeRegistry contract address",
+        "INVALID_ADDRESS"
+      );
+    }
+    this.eventListener = new EventListener(config.publicClient);
+    this.contractClient = new ContractClient(
+      config.publicClient,
+      config.walletClient,
+      config.contracts
+    );
+    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");
+      }
+    }
+  }
+  static chains = {
+    1: mainnet,
+    11155111: sepolia,
+    41454: monadTestnet,
+    31337: hardhat
+  };
+  eventListener;
+  contractClient;
+  initialized = false;
+  protocol;
+  protocolParams;
+  /**
+   * Initialize the SDK
+   */
+  // TODO: Delete this it is redundant
+  async initialize() {
+    if (this.initialized) return;
+    try {
+      await this.contractClient.initialize();
+      this.initialized = true;
+    } catch (error) {
+      throw new SDKError(
+        `Failed to initialize SDK: ${error}`,
+        "SDK_INITIALIZATION_FAILED"
+      );
+    }
+  }
+  /**
+   * 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
+   */
+  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");
+    }
+  }
+  /**
+   * 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
+   */
+  async encryptNumberAndGenProof(data, publicKey, circuit) {
+    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");
+    }
+  }
+  /**
+   * Request a new E3 computation
+   */
+  async requestE3(params) {
+    console.log(">>> REQUEST");
+    if (!this.initialized) {
+      await this.initialize();
+    }
+    return this.contractClient.requestE3(
+      params.filter,
+      params.threshold,
+      params.startWindow,
+      params.duration,
+      params.e3Program,
+      params.e3ProgramParams,
+      params.computeProviderParams,
+      params.value,
+      params.gasLimit
+    );
+  }
+  /**
+   * Activate an E3 computation
+   */
+  async activateE3(e3Id, publicKey, gasLimit) {
+    if (!this.initialized) {
+      await this.initialize();
+    }
+    return this.contractClient.activateE3(e3Id, publicKey, gasLimit);
+  }
+  /**
+   * Publish input for an E3 computation
+   */
+  async publishInput(e3Id, data, gasLimit) {
+    if (!this.initialized) {
+      await this.initialize();
+    }
+    return this.contractClient.publishInput(e3Id, data, gasLimit);
+  }
+  /**
+   * Publish ciphertext output for an E3 computation
+   */
+  async publishCiphertextOutput(e3Id, ciphertextOutput, proof, gasLimit) {
+    if (!this.initialized) {
+      await this.initialize();
+    }
+    return this.contractClient.publishCiphertextOutput(
+      e3Id,
+      ciphertextOutput,
+      proof,
+      gasLimit
+    );
+  }
+  /**
+   * Get E3 information
+   */
+  async getE3(e3Id) {
+    if (!this.initialized) {
+      await this.initialize();
+    }
+    return this.contractClient.getE3(e3Id);
+  }
+  /**
+   * Unified Event Listening - Listen to any Enclave or Registry event
+   */
+  onEnclaveEvent(eventType, callback) {
+    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
+    );
+  }
+  /**
+   * Remove event listener
+   */
+  off(eventType, callback) {
+    this.eventListener.off(eventType, callback);
+  }
+  /**
+   * Handle an event only once
+   */
+  once(type, callback) {
+    const handler = (event) => {
+      this.off(type, handler);
+      const prom = callback(event);
+      if (prom) {
+        prom.catch((e) => console.log(e));
+      }
+    };
+    this.onEnclaveEvent(type, handler);
+  }
+  /**
+   * Get historical events
+   */
+  async getHistoricalEvents(eventType, fromBlock, toBlock) {
+    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
+    );
+  }
+  /**
+   * Start polling for events
+   */
+  async startEventPolling() {
+    void this.eventListener.startPolling();
+  }
+  /**
+   * Stop polling for events
+   */
+  stopEventPolling() {
+    this.eventListener.stopPolling();
+  }
+  /**
+   * Utility methods
+   */
+  /**
+   * Estimate gas for a transaction
+   */
+  async estimateGas(functionName, args, contractAddress, abi, value) {
+    return this.contractClient.estimateGas(
+      functionName,
+      args,
+      contractAddress,
+      abi,
+      value
+    );
+  }
+  /**
+   * Wait for transaction confirmation
+   */
+  async waitForTransaction(hash) {
+    return this.contractClient.waitForTransaction(hash);
+  }
+  /**
+   * Clean up resources
+   */
+  cleanup() {
+    this.eventListener.cleanup();
+  }
+  /**
+   * Update SDK configuration
+   */
+  // TODO: We should delete this as we don't want a stateful client.
+  updateConfig(newConfig) {
+    if (newConfig.publicClient) {
+      this.config.publicClient = newConfig.publicClient;
+      this.eventListener = new EventListener(newConfig.publicClient);
+    }
+    if (newConfig.walletClient) {
+      this.config.walletClient = newConfig.walletClient;
+    }
+    if (newConfig.contracts) {
+      this.config.contracts = {
+        ...this.config.contracts,
+        ...newConfig.contracts
+      };
+    }
+    if (newConfig.chainId) {
+      this.config.chainId = newConfig.chainId;
+    }
+    this.contractClient = new ContractClient(
+      this.config.publicClient,
+      this.config.walletClient,
+      this.config.contracts
+    );
+    this.initialized = false;
+  }
+  static create(options) {
+    const chain = _EnclaveSDK.chains[options.chainId];
+    const isWebSocket = options.rpcUrl.startsWith("ws://") || options.rpcUrl.startsWith("wss://");
+    const transport = isWebSocket ? webSocket(options.rpcUrl, {
+      keepAlive: { interval: 3e4 },
+      reconnect: { attempts: 5, delay: 2e3 }
+    }) : http(options.rpcUrl);
+    const publicClient = createPublicClient({
+      chain,
+      transport
+    });
+    let walletClient = void 0;
+    if (options.privateKey) {
+      const account = privateKeyToAccount(options.privateKey);
+      walletClient = createWalletClient({
+        account,
+        chain,
+        transport
+      });
+    }
+    return new _EnclaveSDK({
+      publicClient,
+      walletClient,
+      contracts: options.contracts,
+      chainId: options.chainId,
+      protocol: options.protocol,
+      protocolParams: options.protocolParams
+    });
+  }
+};
+export {
+  BFV_PARAMS_SET,
+  BfvProtocolParams,
+  ContractClient,
+  DEFAULT_COMPUTE_PROVIDER_PARAMS,
+  DEFAULT_E3_CONFIG,
+  EnclaveEventType,
+  EnclaveSDK,
+  EventListener,
+  FheProtocol,
+  RegistryEventType,
+  SDKError,
+  calculateStartWindow,
+  decodePlaintextOutput,
+  encodeBfvParams,
+  encodeComputeProviderParams,
+  formatBigInt,
+  formatEventName,
+  generateEventId,
+  generateProof,
+  getCurrentTimestamp,
+  isValidAddress,
+  isValidHash,
+  parseBigInt,
+  parseEventData,
+  sleep
+};
+//# sourceMappingURL=index.js.map