@cofhe/sdk 0.1.1 → 0.2.1

package/node/encryptInputs.test.ts

@@ -1,4 +1,4 @@
-import { Encryptable, FheTypes, type CofhesdkClient, type Result, CofhesdkErrorCode, CofhesdkError } from '@/core';
+import { Encryptable, FheTypes, type CofhesdkClient, CofhesdkErrorCode, CofhesdkError } from '@/core';
 import { arbSepolia as cofhesdkArbSepolia } from '@/chains';
 
 import { describe, it, expect, beforeAll, beforeEach } from 'vitest';
@@ -11,22 +11,6 @@ import { createCofhesdkClient, createCofhesdkConfig } from './index.js';
 // Real test setup - using actual node-tfhe
 const TEST_PRIVATE_KEY = '0xac0974bec39a17e36ba4a6b4d238ff944bacb478cbed5efcae784d7bf4f2ff80';
 
-const expectResultSuccess = <T>(result: Result<T>): T => {
-  expect(result.success, `Result error: ${result.error?.toString()}`).toBe(true);
-  return result.data!;
-};
-
-const expectResultError = <T>(result: Result<T>, errorCode?: CofhesdkErrorCode): void => {
-  expect(result.success).toBe(false);
-  expect(result.data).toBe(null);
-  expect(result.error).not.toBe(null);
-  const error = result.error as CofhesdkError;
-  expect(error).toBeInstanceOf(CofhesdkError);
-  if (errorCode) {
-    expect(error.code, `Result error: ${result.error?.toString()}`).toBe(errorCode);
-  }
-};
-
 describe('@cofhe/node - Encrypt Inputs', () => {
   let cofhesdkClient: CofhesdkClient;
   let publicClient: PublicClient;
@@ -59,8 +43,7 @@ describe('@cofhe/node - Encrypt Inputs', () => {
       await cofhesdkClient.connect(publicClient, walletClient);
 
       // This will trigger real TFHE initialization
-      const result = await cofhesdkClient.encryptInputs([Encryptable.uint128(100n)]).encrypt();
-      const encrypted = expectResultSuccess(result);
+      const encrypted = await cofhesdkClient.encryptInputs([Encryptable.uint128(100n)]).encrypt();
 
       // If we get here, TFHE was initialized successfully
       expect(encrypted).toBeDefined();
@@ -70,12 +53,10 @@ describe('@cofhe/node - Encrypt Inputs', () => {
       await cofhesdkClient.connect(publicClient, walletClient);
 
       // First encryption
-      const result1 = await cofhesdkClient.encryptInputs([Encryptable.uint128(100n)]).encrypt();
-      expectResultSuccess(result1);
+      await cofhesdkClient.encryptInputs([Encryptable.uint128(100n)]).encrypt();
 
       // Second encryption should reuse initialization
-      const result2 = await cofhesdkClient.encryptInputs([Encryptable.uint64(50n)]).encrypt();
-      expectResultSuccess(result2);
+      await cofhesdkClient.encryptInputs([Encryptable.uint64(50n)]).encrypt();
     }, 120000);
   });
 
@@ -83,8 +64,7 @@ describe('@cofhe/node - Encrypt Inputs', () => {
     it('should encrypt a bool with real TFHE', async () => {
       await cofhesdkClient.connect(publicClient, walletClient);
 
-      const result = await cofhesdkClient.encryptInputs([Encryptable.bool(true)]).encrypt();
-      const encrypted = expectResultSuccess(result);
+      const encrypted = await cofhesdkClient.encryptInputs([Encryptable.bool(true)]).encrypt();
 
       expect(encrypted.length).toBe(1);
       expect(encrypted[0].utype).toBe(FheTypes.Bool);
@@ -108,8 +88,7 @@ describe('@cofhe/node - Encrypt Inputs', () => {
         Encryptable.address('0x742d35Cc6634C0532925a3b844D16faC4c175E99'),
       ];
 
-      const result = await cofhesdkClient.encryptInputs(inputs).encrypt();
-      const encrypted = expectResultSuccess(result);
+      const encrypted = await cofhesdkClient.encryptInputs(inputs).encrypt();
 
       expect(encrypted.length).toBe(7);
       // Verify each type
@@ -128,14 +107,13 @@ describe('@cofhe/node - Encrypt Inputs', () => {
       await cofhesdkClient.connect(publicClient, walletClient);
 
       const snapshot = cofhesdkClient.getSnapshot();
-      const result = await cofhesdkClient
+      const encrypted = await cofhesdkClient
         .encryptInputs([Encryptable.uint128(100n)])
         .setChainId(snapshot.chainId!)
         .setAccount(snapshot.account!)
         .setSecurityZone(0)
         .encrypt();
 
-      const encrypted = expectResultSuccess(result);
       expect(encrypted.length).toBe(1);
       expect(encrypted[0].utype).toBe(FheTypes.Uint128);
     }, 60000);
@@ -144,9 +122,12 @@ describe('@cofhe/node - Encrypt Inputs', () => {
   describe('Real Error Handling', () => {
     it('should fail gracefully when not connected', async () => {
       // Don't connect the client
-      const result = await cofhesdkClient.encryptInputs([Encryptable.uint128(100n)]).encrypt();
-
-      expectResultError(result, CofhesdkErrorCode.NotConnected);
+      try {
+        await cofhesdkClient.encryptInputs([Encryptable.uint128(100n)]).encrypt();
+      } catch (error) {
+        expect(error).toBeInstanceOf(CofhesdkError);
+        expect((error as CofhesdkError).code).toBe(CofhesdkErrorCode.NotConnected);
+      }
     }, 30000);
 
     it('should handle invalid CoFHE URL', async () => {
@@ -158,17 +139,16 @@ describe('@cofhe/node - Encrypt Inputs', () => {
             verifierUrl: 'http://invalid-verifier-url.local',
           },
         ],
-        fheKeysPrefetching: 'OFF',
       });
 
       const badClient = createCofhesdkClient(badConfig);
       await badClient.connect(publicClient, walletClient);
 
-      const result = await badClient.encryptInputs([Encryptable.uint128(100n)]).encrypt();
-
-      expect(result.success).toBe(false);
-      if (!result.success) {
-        expect(result.error).toBeDefined();
+      try {
+        await badClient.encryptInputs([Encryptable.uint128(100n)]).encrypt();
+      } catch (error) {
+        expect(error).toBeInstanceOf(CofhesdkError);
+        expect((error as CofhesdkError).code).toBe(CofhesdkErrorCode.ZkVerifyFailed);
       }
     }, 60000);
   });

package/node/index.ts

@@ -74,6 +74,7 @@ const zkBuilderAndCrsGenerator: ZkBuilderAndCrsGenerator = (fhe: string, crs: st
  */
 export function createCofhesdkConfig(config: CofhesdkInputConfig): CofhesdkConfig {
   return createCofhesdkConfigBase({
+    environment: 'node',
     ...config,
     fheKeyStorage: config.fheKeyStorage === null ? null : config.fheKeyStorage ?? createNodeStorage(),
   });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cofhe/sdk",
-  "version": "0.1.1",
+  "version": "0.2.1",
   "type": "module",
   "description": "SDK for Fhenix COFHE coprocessor interaction",
   "main": "./dist/core.cjs",
@@ -57,21 +57,21 @@
     "CHANGELOG.md"
   ],
   "dependencies": {
+    "iframe-shared-storage": "^1.0.34",
     "immer": "^10.1.1",
-    "zustand": "^5.0.1",
-    "zod": "^3.22.0",
-    "viem": "^2.0.0",
     "node-tfhe": "0.11.1",
-    "idb-keyval": "^6.2.1",
     "tfhe": "0.11.1",
-    "tweetnacl": "^1.0.3"
+    "tweetnacl": "^1.0.3",
+    "viem": "^2.38.6",
+    "zod": "^4.0.0",
+    "zustand": "^5.0.1"
   },
   "peerDependencies": {
-    "viem": "^2.0.0",
+    "@nomicfoundation/hardhat-ethers": "^3.0.0",
     "@wagmi/core": "^2.0.0",
     "ethers": "^5.0.0 || ^6.0.0",
     "hardhat": "^2.0.0",
-    "@nomicfoundation/hardhat-ethers": "^3.0.0"
+    "viem": "^2.38.6"
   },
   "peerDependenciesMeta": {
     "@wagmi/core": {
@@ -88,21 +88,21 @@
     }
   },
   "devDependencies": {
+    "@nomicfoundation/hardhat-ethers": "^3.0.0",
     "@types/node": "^20.0.0",
     "@vitest/browser": "^3.0.0",
     "@vitest/coverage-v8": "^3.0.0",
     "eslint": "^8.57.0",
+    "ethers5": "npm:ethers@^5.7.2",
+    "ethers6": "npm:ethers@^6.13.0",
     "happy-dom": "^15.0.0",
+    "hardhat": "^2.19.0",
     "playwright": "^1.55.0",
     "tsup": "^8.0.2",
     "typescript": "5.5.4",
     "vitest": "^3.0.0",
-    "ethers5": "npm:ethers@^5.7.2",
-    "ethers6": "npm:ethers@^6.13.0",
-    "hardhat": "^2.19.0",
-    "@nomicfoundation/hardhat-ethers": "^3.0.0",
-    "@cofhe/eslint-config": "0.1.1",
-    "@cofhe/tsconfig": "0.1.0"
+    "@cofhe/eslint-config": "0.2.0",
+    "@cofhe/tsconfig": "0.1.1"
   },
   "publishConfig": {
     "access": "public"
@@ -111,7 +111,7 @@
     "build": "tsup",
     "dev": "tsup --watch",
     "lint": "eslint \"**/*.ts*\"",
-    "type-check": "tsc --noEmit",
+    "check:types": "tsc --noEmit",
     "clean": "rm -rf .turbo && rm -rf node_modules && rm -rf dist",
     "test": "vitest run",
     "test:watch": "vitest",

package/permits/index.ts

@@ -53,6 +53,7 @@ export {
   setActivePermitHash,
   removeActivePermitHash,
   clearStaleStore,
+  PERMIT_STORE_DEFAULTS,
 } from './store.js';
 
 // Sealing utilities

package/permits/localstorage.test.ts

@@ -1,7 +1,6 @@
 /**
  * @vitest-environment happy-dom
  */
-/* eslint-disable no-unused-vars */
 
 import { describe, it, expect, beforeEach, afterEach } from 'vitest';
 import {
@@ -40,7 +39,6 @@ describe('Permits localStorage Tests', () => {
 
   it('should persist permits to localStorage', async () => {
     const permit = await createMockPermit();
-    const hash = PermitUtils.getHash(permit);
 
     setPermit(chainId, account, permit);
 
@@ -49,40 +47,38 @@ describe('Permits localStorage Tests', () => {
     expect(storedData).toBeDefined();
 
     const parsedData = JSON.parse(storedData!);
-    expect(parsedData.state.permits[chainId][account][hash]).toBeDefined();
+    expect(parsedData.state.permits[chainId][account][permit.hash]).toBeDefined();
   });
 
   it('should persist active permit hash to localStorage', async () => {
     const permit = await createMockPermit();
-    const hash = PermitUtils.getHash(permit);
 
     setPermit(chainId, account, permit);
-    setActivePermitHash(chainId, account, hash);
+    setActivePermitHash(chainId, account, permit.hash);
 
     // Verify active permit hash is stored
     const storedData = localStorage.getItem('cofhesdk-permits');
     expect(storedData).toBeDefined();
 
     const parsedData = JSON.parse(storedData!);
-    expect(parsedData.state.activePermitHash[chainId][account]).toBe(hash);
+    expect(parsedData.state.activePermitHash[chainId][account]).toBe(permit.hash);
   });
 
   it('should restore permits from localStorage', async () => {
     const permit = await createMockPermit();
-    const hash = PermitUtils.getHash(permit);
 
     // Add permit to localStorage
     setPermit(chainId, account, permit);
-    setActivePermitHash(chainId, account, hash);
+    setActivePermitHash(chainId, account, permit.hash);
     const serializedPermit = PermitUtils.serialize(permit);
 
     // Verify data is restored
-    const retrievedPermit = getPermit(chainId, account, hash);
+    const retrievedPermit = getPermit(chainId, account, permit.hash);
     expect(retrievedPermit).toBeDefined();
     expect(PermitUtils.serialize(retrievedPermit!)).toEqual(serializedPermit);
 
     const activeHash = getActivePermitHash(chainId, account);
-    expect(activeHash).toBe(hash);
+    expect(activeHash).toBe(permit.hash);
   });
 
   it('should handle corrupted localStorage data gracefully', () => {
@@ -97,22 +93,21 @@ describe('Permits localStorage Tests', () => {
 
   it('should clean up localStorage when permits are removed', async () => {
     const permit = await createMockPermit();
-    const hash = PermitUtils.getHash(permit);
 
     setPermit(chainId, account, permit);
-    setActivePermitHash(chainId, account, hash);
+    setActivePermitHash(chainId, account, permit.hash);
 
     // Verify data exists
     let storedData = localStorage.getItem('cofhesdk-permits');
     expect(storedData).toBeDefined();
 
     // Remove permit
-    removePermit(chainId, account, hash, true);
+    removePermit(chainId, account, permit.hash);
 
     // Verify data is cleaned up
     storedData = localStorage.getItem('cofhesdk-permits');
     const parsedData = JSON.parse(storedData!);
-    expect(parsedData.state.permits[chainId][account][hash]).toBeUndefined();
+    expect(parsedData.state.permits[chainId][account][permit.hash]).toBeUndefined();
     expect(parsedData.state.activePermitHash[chainId][account]).toBeUndefined();
   });
 });

package/permits/onchain-utils.ts

@@ -0,0 +1,221 @@
+import {
+  BaseError,
+  ContractFunctionRevertedError,
+  type Hex,
+  type PublicClient,
+  decodeErrorResult,
+  parseAbi,
+} from 'viem';
+import type { EIP712Domain, Permission } from './types';
+import { TASK_MANAGER_ADDRESS } from '../core/consts.js';
+
+export const getAclAddress = async (publicClient: PublicClient): Promise<Hex> => {
+  const ACL_IFACE = 'function acl() view returns (address)';
+
+  // Parse the ABI for the ACL function
+  const aclAbi = parseAbi([ACL_IFACE]);
+
+  // Get the ACL address
+  return (await publicClient.readContract({
+    address: TASK_MANAGER_ADDRESS as `0x${string}`,
+    abi: aclAbi,
+    functionName: 'acl',
+  })) as `0x${string}`;
+};
+
+export const getAclEIP712Domain = async (publicClient: PublicClient): Promise<EIP712Domain> => {
+  const aclAddress = await getAclAddress(publicClient);
+  const EIP712_DOMAIN_IFACE =
+    'function eip712Domain() public view returns (bytes1 fields, string name, string version, uint256 chainId, address verifyingContract, bytes32 salt, uint256[] extensions)';
+
+  // Parse the ABI for the EIP712 domain function
+  const domainAbi = parseAbi([EIP712_DOMAIN_IFACE]);
+
+  // Get the EIP712 domain
+  const domain = await publicClient.readContract({
+    address: aclAddress,
+    abi: domainAbi,
+    functionName: 'eip712Domain',
+  });
+
+  // eslint-disable-next-line no-unused-vars
+  const [_fields, name, version, chainId, verifyingContract, _salt, _extensions] = domain;
+
+  return {
+    name,
+    version,
+    chainId: Number(chainId),
+    verifyingContract,
+  };
+};
+
+export const checkPermitValidityOnChain = async (
+  permission: Permission,
+  publicClient: PublicClient
+): Promise<boolean> => {
+  const aclAddress = await getAclAddress(publicClient);
+
+  // Check if the permit is valid
+  try {
+    await publicClient.simulateContract({
+      address: aclAddress,
+      abi: checkPermitValidityAbi,
+      functionName: 'checkPermitValidity',
+      args: [
+        {
+          issuer: permission.issuer,
+          expiration: BigInt(permission.expiration),
+          recipient: permission.recipient,
+          validatorId: BigInt(permission.validatorId),
+          validatorContract: permission.validatorContract,
+          sealingKey: permission.sealingKey,
+          issuerSignature: permission.issuerSignature,
+          recipientSignature: permission.recipientSignature,
+        },
+      ],
+    });
+    return true;
+  } catch (err: any) {
+    // Viem default handling
+    if (err instanceof BaseError) {
+      const revertError = err.walk((err: any) => err instanceof ContractFunctionRevertedError);
+      if (revertError instanceof ContractFunctionRevertedError) {
+        const errorName = revertError.data?.errorName ?? '';
+        throw new Error(errorName);
+      }
+    }
+
+    // Check details field for custom error names (e.g., from Hardhat test nodes)
+    const customErrorName = extractCustomErrorFromDetails(err, checkPermitValidityAbi);
+    if (customErrorName) {
+      throw new Error(customErrorName);
+    }
+
+    // Hardhat wrapped error will need to be unwrapped to get the return data
+    const hhDetailsData = extractReturnData(err);
+    if (hhDetailsData != null) {
+      const decoded = decodeErrorResult({
+        abi: checkPermitValidityAbi,
+        data: hhDetailsData,
+      });
+
+      throw new Error(decoded.errorName);
+    }
+
+    // Fallback throw the original error
+    throw err;
+  }
+};
+
+function extractCustomErrorFromDetails(err: unknown, abi: readonly any[]): string | undefined {
+  // Check details field for custom error names (e.g., from Hardhat test nodes)
+  const anyErr = err as any;
+  const details = anyErr?.details ?? anyErr?.cause?.details;
+
+  if (typeof details === 'string') {
+    // Match pattern: "reverted with custom error 'ErrorName()'"
+    const customErrorMatch = details.match(/reverted with custom error '(\w+)\(\)'/);
+    if (customErrorMatch) {
+      const errorName = customErrorMatch[1];
+      // Check if this error exists in our ABI
+      const errorExists = abi.some((item) => item.type === 'error' && item.name === errorName);
+      if (errorExists) {
+        return errorName;
+      }
+    }
+  }
+
+  return undefined;
+}
+
+function extractReturnData(err: unknown): `0x${string}` | undefined {
+  // viem BaseError has `details`, but fall back to any message-like string we can find
+  const anyErr = err as any;
+  const s = anyErr?.details ?? anyErr?.cause?.details ?? anyErr?.shortMessage ?? anyErr?.message ?? String(err);
+
+  return s.match(/return data:\s*(0x[a-fA-F0-9]+)/)?.[1] as `0x${string}` | undefined;
+}
+
+const checkPermitValidityAbi = [
+  {
+    type: 'function',
+    name: 'checkPermitValidity',
+    inputs: [
+      {
+        name: 'permission',
+        type: 'tuple',
+        internalType: 'struct Permission',
+        components: [
+          {
+            name: 'issuer',
+            type: 'address',
+            internalType: 'address',
+          },
+          {
+            name: 'expiration',
+            type: 'uint64',
+            internalType: 'uint64',
+          },
+          {
+            name: 'recipient',
+            type: 'address',
+            internalType: 'address',
+          },
+          {
+            name: 'validatorId',
+            type: 'uint256',
+            internalType: 'uint256',
+          },
+          {
+            name: 'validatorContract',
+            type: 'address',
+            internalType: 'address',
+          },
+          {
+            name: 'sealingKey',
+            type: 'bytes32',
+            internalType: 'bytes32',
+          },
+          {
+            name: 'issuerSignature',
+            type: 'bytes',
+            internalType: 'bytes',
+          },
+          {
+            name: 'recipientSignature',
+            type: 'bytes',
+            internalType: 'bytes',
+          },
+        ],
+      },
+    ],
+    outputs: [
+      {
+        name: '',
+        type: 'bool',
+        internalType: 'bool',
+      },
+    ],
+    stateMutability: 'view',
+  },
+  {
+    type: 'error',
+    name: 'PermissionInvalid_Disabled',
+    inputs: [],
+  },
+  {
+    type: 'error',
+    name: 'PermissionInvalid_Expired',
+    inputs: [],
+  },
+  {
+    type: 'error',
+    name: 'PermissionInvalid_IssuerSignature',
+    inputs: [],
+  },
+  {
+    type: 'error',
+    name: 'PermissionInvalid_RecipientSignature',
+    inputs: [],
+  },
+] as const;