Feat/migrate to cofhesdk

packages/hardhat/hardhat.config.ts

@@ -13,7 +13,7 @@ import { task } from "hardhat/config";
 import generateTsAbis from "./scripts/generateTsAbis";
 
 import "@nomicfoundation/hardhat-toolbox";
-import "cofhe-hardhat-plugin";
+import "@cofhe/hardhat-plugin";
 
 // If not set, it uses ours Alchemy's default API key.
 // You can get your own at https://dashboard.alchemyapi.io

packages/hardhat/package.json

@@ -31,10 +31,11 @@
     "qrcode": "~1.5.4"
   },
   "devDependencies": {
+    "@cofhe/hardhat-plugin": "0.0.0-beta-20251103142716",
+    "@cofhe/sdk": "0.0.0-beta-20251103142716",
     "@ethersproject/abi": "~5.7.0",
     "@ethersproject/providers": "~5.7.2",
     "@fhenixprotocol/cofhe-contracts": "0.0.13",
-    "@fhenixprotocol/cofhe-mock-contracts": "^0.3.0",
     "@nomicfoundation/hardhat-chai-matchers": "~2.0.7",
     "@nomicfoundation/hardhat-ethers": "~3.0.8",
     "@nomicfoundation/hardhat-ignition": "^0.15.11",
@@ -52,8 +53,6 @@
     "@typescript-eslint/eslint-plugin": "~8.27.0",
     "@typescript-eslint/parser": "~8.27.0",
     "chai": "~4.5.0",
-    "cofhe-hardhat-plugin": "^0.3.0",
-    "cofhejs": "^0.3.0",
     "eslint": "~9.23.0",
     "eslint-config-prettier": "~10.1.1",
     "eslint-plugin-prettier": "~5.2.4",

packages/hardhat/test/FHECounter.test.ts

@@ -1,15 +1,15 @@
 /* eslint-disable @typescript-eslint/no-unused-vars */
 import { loadFixture } from "@nomicfoundation/hardhat-toolbox/network-helpers";
 import hre from "hardhat";
-import { cofhejs, Encryptable, FheTypes } from "cofhejs/node";
+import { Encryptable, FheTypes } from "@cofhe/sdk";
 
 /**
  * @file FHECounter.test.ts
  * @description Test suite for the FHECounter contract demonstrating FHE operations and testing utilities
  *
  * This test suite showcases the use of FHE testing tools and utilities:
- * - hre.cofhe: Internal FHE testing utilities
- * - cofhejs: FHE operations library
+ * - hre.cofhesdk: Internal FHE testing utilities
+ * - cofhe client: FHE operations interface
  * - Mock environment testing for FHE operations
  */
 
@@ -35,119 +35,120 @@ describe("Counter", function () {
      * - Provides options for enabling/disabling FHE operation logging
      */
     beforeEach(function () {
-      if (!hre.cofhe.isPermittedEnvironment("MOCK")) this.skip();
-
       // NOTE: Uncomment for global logging
-      // hre.cofhe.mocks.enableLogs()
+      // hre.cofhesdk.mocks.enableLogs();
     });
 
     afterEach(function () {
-      if (!hre.cofhe.isPermittedEnvironment("MOCK")) return;
-
       // NOTE: Uncomment for global logging
-      // hre.cofhe.mocks.disableLogs()
+      // hre.cofhesdk.mocks.disableLogs()
     });
 
     /**
      * @dev Tests the basic increment functionality
      * Demonstrates:
-     * - Reading encrypted values using hre.cofhe.mocks.expectPlaintext
-     * - Logging FHE operations using hre.cofhe.mocks.withLogs
+     * - Reading encrypted values using hre.cofhesdk.mocks.expectPlaintext
+     * - Logging FHE operations using hre.cofhesdk.mocks.withLogs
      */
     it("Should increment the counter", async function () {
       const { counter, bob } = await loadFixture(deployCounterFixture);
       const count = await counter.count();
 
-      // `hre.cofhe.mocks.expectPlaintext` is used to verify that the encrypted value is 0
+      // `hre.cofhesdk.mocks.expectPlaintext` is used to verify that the encrypted value is 0
       // This uses the encrypted variable `count` and retrieves the plaintext value from the on-chain mock contracts
       // This kind of test can only be done in a mock environment where the plaintext value is known
-      await hre.cofhe.mocks.expectPlaintext(count, 0n);
+      await hre.cofhesdk.mocks.expectPlaintext(count, 0n);
 
-      // `hre.cofhe.mocks.withLogs` is used to log the FHE operations
+      // `hre.cofhesdk.mocks.withLogs` is used to log the FHE operations
       // This is useful for debugging and understanding the FHE operations
       // It will log the FHE operations to the console
-      await hre.cofhe.mocks.withLogs("counter.increment()", async () => {
+      await hre.cofhesdk.mocks.withLogs("counter.increment()", async () => {
         await counter.connect(bob).increment();
       });
 
       const count2 = await counter.count();
-      await hre.cofhe.mocks.expectPlaintext(count2, 1n);
+      await hre.cofhesdk.mocks.expectPlaintext(count2, 1n);
     });
 
     /**
-     * @dev Tests the cofhejs unseal functionality in mock environment
+     * @dev Tests the cofhesdk unseal functionality in mock environment
      * Demonstrates:
      * - Initializing FHE with a Hardhat signer
-     * - Reading and unsealing encrypted values
+     * - Reading with transparently unsealing encrypted values
      * - Verifying unsealed values match expectations
      */
-    it("cofhejs unseal (mocks)", async function () {
-      await hre.cofhe.mocks.enableLogs("cofhejs unseal (mocks)");
+    it("cofhesdk decrypt (mocks)", async function () {
+      await hre.cofhesdk.mocks.enableLogs("cofhesdk decrypt (mocks)");
       const { counter, bob } = await loadFixture(deployCounterFixture);
 
-      // `hre.cofhe.initializeWithHardhatSigner` is used to initialize FHE with a Hardhat signer
-      // Initialization is required before any `cofhejs.unseal` or `cofhejs.encrypt` operations can be performed
-      // `initializeWithHardhatSigner` is a helper function that initializes FHE with a Hardhat signer
-      // It returns a `Promise<Result<>>` type.
+      // `hre.cofhesdk.createBatteriesIncludedCofhesdkClient` is used to initialize FHE with a Hardhat signer
+      // Initialization is required before any `encrypt` or `decrypt` operations can be performed
+      // `createBatteriesIncludedCofhesdkClient` is a helper function that initializes FHE with a Hardhat signer
+      // Returns a `Promise<CofhesdkClient>` type.
+
+      const client = await hre.cofhesdk.createBatteriesIncludedCofhesdkClient(bob);
+
+      const count = await counter.count();
 
+      // `decryptHandle` is used to unseal the encrypted value
+      // the client must be initialized and connected before `unseal` can be called
+      // `decrypt` returns a `Promise<Result<T>>` type.
+      const unsealedResult = await client.decryptHandle(count, FheTypes.Uint32).decrypt();
       // The `Result<T>` type looks like this:
       // {
       //   success: boolean,
       //   data: T (Permit | undefined in the case of initializeWithHardhatSigner),
-      //   error: CofhejsError | null,
+      //   error: CofhesdkError | null,
       // }
-      const initializeResult = await hre.cofhe.initializeWithHardhatSigner(bob);
-
-      // `hre.cofhe.expectResultSuccess` is used to verify that the `Result` is successful (success: true)
-      // If the `Result` is not successful, the test will fail
-      await hre.cofhe.expectResultSuccess(initializeResult);
-
-      const count = await counter.count();
 
-      // `cofhejs.unseal` is used to unseal the encrypted value
-      // cofhejs must be initialized before `unseal` can be called
-      const unsealedResult = await cofhejs.unseal(count, FheTypes.Uint32);
-
-      // `hre.cofhe.expectResultValue` is used to verify that the `Result.data` is the expected value
+      // `hre.cofhesdk.expectResultValue` is used to verify that the `Result.data` is the expected value
       // If the `Result.data` is not the expected value, the test will fail
-      await hre.cofhe.expectResultValue(unsealedResult, 0n);
+      await hre.cofhesdk.expectResultValue(unsealedResult, 0n);
 
       await counter.connect(bob).increment();
 
       const count2 = await counter.count();
-      const unsealedResult2 = await cofhejs.unseal(count2, FheTypes.Uint32);
-      await hre.cofhe.expectResultValue(unsealedResult2, 1n);
+      const unsealedResult2 = await client.decryptHandle(count2, FheTypes.Uint32).decrypt();
+      await hre.cofhesdk.expectResultValue(unsealedResult2, 1n);
 
-      await hre.cofhe.mocks.disableLogs();
+      await hre.cofhesdk.mocks.disableLogs();
     });
 
     /**
-     * @dev Tests the cofhejs encryption and value setting functionality
+     * @dev Tests the cofhesdk encryption and value setting functionality
      * Demonstrates:
-     * - Encrypting values using cofhejs
+     * - Encrypting values using cofhesdk
      * - Setting encrypted values in the contract
      * - Verifying encrypted values using both mocks and unsealing
      */
-    it("cofhejs encrypt (mocks)", async function () {
+    it("cofhesdk encrypt (mocks)", async function () {
       const { counter, bob } = await loadFixture(deployCounterFixture);
 
-      const initializeResult = await hre.cofhe.initializeWithHardhatSigner(bob);
-      await hre.cofhe.expectResultSuccess(initializeResult);
+      const client = await hre.cofhesdk.createBatteriesIncludedCofhesdkClient(bob);
+
+      // `encryptInputs` is used to encrypt the value
+      // the client must be initialized and connected before `encryptInputs` can be called
+      // `encrypt` returns a `Promise<Result<T>>` type.
 
-      // `cofhejs.encrypt` is used to encrypt the value
-      // cofhejs must be initialized before `encrypt` can be called
-      const encryptResult = await cofhejs.encrypt([Encryptable.uint32(5n)] as const);
+      const encryptResult = await client.encryptInputs([Encryptable.uint32(5n)]).encrypt();
+      // The `Result<T>` type looks like this:
+      // {
+      //   success: boolean,
+      //   data: T (Permit | undefined in the case of initializeWithHardhatSigner),
+      //   error: CofhesdkError | null,
+      // }
 
-      const [encryptedInput] = await hre.cofhe.expectResultSuccess(encryptResult);
-      await hre.cofhe.mocks.expectPlaintext(encryptedInput.ctHash, 5n);
+      const [encryptedInput] = await hre.cofhesdk.expectResultSuccess(encryptResult);
+      await hre.cofhesdk.mocks.expectPlaintext(encryptedInput.ctHash, 5n);
 
       await counter.connect(bob).set(encryptedInput);
 
       const count = await counter.count();
-      await hre.cofhe.mocks.expectPlaintext(count, 5n);
+      await hre.cofhesdk.mocks.expectPlaintext(count, 5n);
+
+      const unsealedResult = await client.decryptHandle(count, FheTypes.Uint32).decrypt();
 
-      const unsealedResult = await cofhejs.unseal(count, FheTypes.Uint32);
-      await hre.cofhe.expectResultValue(unsealedResult, 5n);
+      await hre.cofhesdk.expectResultValue(unsealedResult, 5n);
     });
   });
 });

packages/nextjs/app/FHECounterComponent.tsx

@@ -2,7 +2,7 @@
 
 import { useCallback, useState } from "react";
 import { useEncryptInput } from "./useEncryptInput";
-import { FheTypes } from "cofhejs/web";
+import { FheTypes } from "@cofhe/sdk";
 import { IntegerInput, IntegerVariant } from "~~/components/scaffold-eth";
 import { EncryptedValue } from "~~/components/scaffold-eth/EncryptedValueCard";
 import { useScaffoldReadContract, useScaffoldWriteContract } from "~~/hooks/scaffold-eth";
@@ -40,7 +40,7 @@ export const FHECounterComponent = () => {
  *
  * Demonstrates the process of encrypting user input before sending it to the blockchain:
  * 1. User enters a number in the input field
- * 2. When "Set" is clicked, the number is encrypted using cofhejs
+ * 2. When "Set" is clicked, the number is encrypted using CoFHE SDK
  * 3. The encrypted value is then sent to the smart contract
  *
  * This ensures the actual value is never exposed on the blockchain,