@cofhe/sdk 0.1.1 → 0.2.0

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.0",
   "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": "^3.22.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"

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 {

package/permits/permit.test.ts

@@ -44,7 +44,7 @@ describe('PermitUtils Tests', () => {
         name: 'Test Permit',
       };
 
-      const permit = await PermitUtils.createSelf(options);
+      const permit = PermitUtils.createSelf(options);
 
       expect(permit.type).toBe('self');
       expect(permit.name).toBe('Test Permit');
@@ -66,7 +66,7 @@ describe('PermitUtils Tests', () => {
         name: 'Test Permit',
       };
 
-      await expect(PermitUtils.createSelf(options)).rejects.toThrow();
+      expect(() => PermitUtils.createSelf(options)).toThrowError();
     });
   });
 
@@ -79,7 +79,7 @@ describe('PermitUtils Tests', () => {
         name: 'Test Sharing Permit',
       };
 
-      const permit = await PermitUtils.createSharing(options);
+      const permit = PermitUtils.createSharing(options);
 
       expect(permit.type).toBe('sharing');
       expect(permit.name).toBe('Test Sharing Permit');
@@ -103,7 +103,7 @@ describe('PermitUtils Tests', () => {
         name: 'Test Sharing Permit',
       };
 
-      await expect(PermitUtils.createSharing(options)).rejects.toThrow();
+      expect(() => PermitUtils.createSharing(options)).toThrow();
     });
   });
 
@@ -116,7 +116,7 @@ describe('PermitUtils Tests', () => {
         name: 'Test Import Permit',
       };
 
-      const permit = await PermitUtils.importShared(options);
+      const permit = PermitUtils.importShared(options);
 
       expect(permit.type).toBe('recipient');
       expect(permit.name).toBe('Test Import Permit');
@@ -140,7 +140,7 @@ describe('PermitUtils Tests', () => {
 
       const stringOptions = JSON.stringify(options);
 
-      const permit = await PermitUtils.importShared(stringOptions);
+      const permit = PermitUtils.importShared(stringOptions);
 
       expect(permit.type).toBe('recipient');
     });
@@ -153,7 +153,7 @@ describe('PermitUtils Tests', () => {
         issuerSignature: '0x1234567890abcdef',
       } as unknown as ImportSharedPermitOptions;
 
-      await expect(PermitUtils.importShared(options)).rejects.toThrow();
+      expect(() => PermitUtils.importShared(options)).toThrow();
 
       const options2 = {
         type: 'recipient',
@@ -162,7 +162,7 @@ describe('PermitUtils Tests', () => {
         issuerSignature: '0x1234567890abcdef',
       } as unknown as ImportSharedPermitOptions;
 
-      await expect(PermitUtils.importShared(options2)).rejects.toThrow();
+      expect(() => PermitUtils.importShared(options2)).toThrow();
     });
 
     it('should throw error for missing issuerSignature', async () => {
@@ -173,7 +173,7 @@ describe('PermitUtils Tests', () => {
         name: 'Test Import Permit',
       };
 
-      await expect(PermitUtils.importShared(options)).rejects.toThrow();
+      expect(() => PermitUtils.importShared(options)).toThrow();
     });
   });
 
@@ -266,7 +266,7 @@ describe('PermitUtils Tests', () => {
 
   describe('sign', () => {
     it('should sign a self permit', async () => {
-      const permit = await PermitUtils.createSelf({
+      const permit = PermitUtils.createSelf({
         issuer: bobAddress,
         name: 'Test Permit',
       });
@@ -280,7 +280,7 @@ describe('PermitUtils Tests', () => {
     });
 
     it('should sign a recipient permit', async () => {
-      const permit = await PermitUtils.importShared({
+      const permit = PermitUtils.importShared({
         issuer: bobAddress,
         recipient: aliceAddress,
         issuerSignature: '0xexisting-signature',
@@ -295,7 +295,7 @@ describe('PermitUtils Tests', () => {
     });
 
     it('should throw error for undefined signer', async () => {
-      const permit = await PermitUtils.createSelf({
+      const permit = PermitUtils.createSelf({
         issuer: bobAddress,
         name: 'Test Permit',
       });
@@ -309,7 +309,7 @@ describe('PermitUtils Tests', () => {
 
   describe('serialize/deserialize', () => {
     it('should serialize and deserialize a permit', async () => {
-      const originalPermit = await PermitUtils.createSelf({
+      const originalPermit = PermitUtils.createSelf({
         issuer: bobAddress,
         name: 'Test Permit',
       });
@@ -348,12 +348,15 @@ describe('PermitUtils Tests', () => {
 
   describe('getHash', () => {
     it('should generate consistent hash for same permit data', async () => {
-      const permit1 = await PermitUtils.createSelf({
+      const expiration = Math.floor(Date.now() / 1000) + 3600; // 1 hour from now
+      const permit1 = PermitUtils.createSelf({
+        expiration,
         issuer: bobAddress,
         name: 'Test Permit',
       });
 
-      const permit2 = await PermitUtils.createSelf({
+      const permit2 = PermitUtils.createSelf({
+        expiration,
         issuer: bobAddress,
         name: 'Test Permit',
       });
@@ -367,7 +370,7 @@ describe('PermitUtils Tests', () => {
 
   describe('export', () => {
     it('should export permit data without sensitive fields', async () => {
-      const permit = await PermitUtils.createSelf({
+      const permit = PermitUtils.createSelf({
         issuer: bobAddress,
         name: 'Test Permit',
       });
@@ -384,7 +387,7 @@ describe('PermitUtils Tests', () => {
 
   describe('updateName', () => {
     it('should update permit name immutably', async () => {
-      const permit = await PermitUtils.createSelf({
+      const permit = PermitUtils.createSelf({
         issuer: bobAddress,
         name: 'Original Name',
       });
@@ -399,13 +402,13 @@ describe('PermitUtils Tests', () => {
 
   describe('validation helpers', () => {
     it('should check if permit is expired', async () => {
-      const expiredPermit = await PermitUtils.createSelf({
+      const expiredPermit = PermitUtils.createSelf({
         issuer: bobAddress,
         name: 'Test Permit',
         expiration: Math.floor(Date.now() / 1000) - 3600, // 1 hour ago
       });
 
-      const validPermit = await PermitUtils.createSelf({
+      const validPermit = PermitUtils.createSelf({
         issuer: bobAddress,
         name: 'Test Permit',
         expiration: Math.floor(Date.now() / 1000) + 3600, // 1 hour from now
@@ -416,7 +419,7 @@ describe('PermitUtils Tests', () => {
     });
 
     it('should check if permit is signed', async () => {
-      const unsignedPermit = await PermitUtils.createSelf({
+      const unsignedPermit = PermitUtils.createSelf({
         issuer: bobAddress,
         name: 'Test Permit',
       });
@@ -428,7 +431,7 @@ describe('PermitUtils Tests', () => {
     });
 
     it('should check overall validity', async () => {
-      const validPermit = await PermitUtils.createSelf({
+      const validPermit = PermitUtils.createSelf({
         issuer: bobAddress,
         name: 'Test Permit',
         expiration: Math.floor(Date.now() / 1000) + 3600,
@@ -456,7 +459,7 @@ describe('PermitUtils Tests', () => {
     }, 10000); // 10 second timeout for network call
 
     it('should check signed domain validity with real contract data', async () => {
-      const permit = await PermitUtils.createSelf({
+      const permit = PermitUtils.createSelf({
         type: 'self',
         issuer: bobAddress,
         name: 'Test Permit',

package/permits/permit.ts

@@ -1,6 +1,9 @@
 import { keccak256, toHex, zeroAddress, parseAbi, type PublicClient, type WalletClient } from 'viem';
 import {
   type Permit,
+  type SelfPermit,
+  type SharingPermit,
+  type RecipientPermit,
   type CreateSelfPermitOptions,
   type CreateSharingPermitOptions,
   type ImportSharedPermitOptions,
@@ -28,7 +31,7 @@ export const PermitUtils = {
   /**
    * Create a self permit for personal use
    */
-  createSelf: async (options: CreateSelfPermitOptions): Promise<Permit> => {
+  createSelf: (options: CreateSelfPermitOptions): SelfPermit => {
     const validation = validateSelfPermitOptions(options);
 
     if (!validation.success) {
@@ -38,19 +41,21 @@ export const PermitUtils = {
     }
 
     // Always generate a new sealing key - users cannot provide their own
-    const sealingPair = await GenerateSealingKey();
+    const sealingPair = GenerateSealingKey();
 
-    return {
+    const permit = {
       ...validation.data,
       sealingPair,
       _signedDomain: undefined,
-    };
+    } satisfies SelfPermit;
+
+    return permit;
   },
 
   /**
    * Create a sharing permit to be shared with another user
    */
-  createSharing: async (options: CreateSharingPermitOptions): Promise<Permit> => {
+  createSharing: (options: CreateSharingPermitOptions): SharingPermit => {
     const validation = validateSharingPermitOptions(options);
 
     if (!validation.success) {
@@ -61,19 +66,21 @@ export const PermitUtils = {
     }
 
     // Always generate a new sealing key - users cannot provide their own
-    const sealingPair = await GenerateSealingKey();
+    const sealingPair = GenerateSealingKey();
 
-    return {
+    const permit = {
       ...validation.data,
       sealingPair,
       _signedDomain: undefined,
-    };
+    } satisfies SharingPermit;
+
+    return permit;
   },
 
   /**
    * Import a shared permit from various input formats
    */
-  importShared: async (options: ImportSharedPermitOptions | any | string): Promise<Permit> => {
+  importShared: (options: ImportSharedPermitOptions | string): RecipientPermit => {
     let parsedOptions: ImportSharedPermitOptions;
 
     // Handle different input types
@@ -107,19 +114,21 @@ export const PermitUtils = {
     }
 
     // Always generate a new sealing key - users cannot provide their own
-    const sealingPair = await GenerateSealingKey();
+    const sealingPair = GenerateSealingKey();
 
-    return {
+    const permit = {
       ...validation.data,
       sealingPair,
       _signedDomain: undefined,
-    };
+    } satisfies RecipientPermit;
+
+    return permit;
   },
 
   /**
    * Sign a permit with the provided wallet client
    */
-  sign: async (permit: Permit, publicClient: PublicClient, walletClient: WalletClient): Promise<Permit> => {
+  sign: async <T extends Permit>(permit: T, publicClient: PublicClient, walletClient: WalletClient): Promise<T> => {
     if (walletClient == null || walletClient.account == null) {
       throw new Error(
         'PermitUtils :: sign - walletClient undefined, you must pass in a `walletClient` for the connected user to create a permit signature'
@@ -153,7 +162,7 @@ export const PermitUtils = {
       };
     }
 
-    return updatedPermit;
+    return updatedPermit as T;
   },
 
   /**
@@ -163,8 +172,8 @@ export const PermitUtils = {
     options: CreateSelfPermitOptions,
     publicClient: PublicClient,
     walletClient: WalletClient
-  ): Promise<Permit> => {
-    const permit = await PermitUtils.createSelf(options);
+  ): Promise<SelfPermit> => {
+    const permit = PermitUtils.createSelf(options);
     return PermitUtils.sign(permit, publicClient, walletClient);
   },
 
@@ -175,8 +184,8 @@ export const PermitUtils = {
     options: CreateSharingPermitOptions,
     publicClient: PublicClient,
     walletClient: WalletClient
-  ): Promise<Permit> => {
-    const permit = await PermitUtils.createSharing(options);
+  ): Promise<SharingPermit> => {
+    const permit = PermitUtils.createSharing(options);
     return PermitUtils.sign(permit, publicClient, walletClient);
   },
 
@@ -184,11 +193,11 @@ export const PermitUtils = {
    * Import and sign a shared permit in one operation from various input formats
    */
   importSharedAndSign: async (
-    options: ImportSharedPermitOptions | any | string,
+    options: ImportSharedPermitOptions | string,
     publicClient: PublicClient,
     walletClient: WalletClient
-  ): Promise<Permit> => {
-    const permit = await PermitUtils.importShared(options);
+  ): Promise<RecipientPermit> => {
+    const permit = PermitUtils.importShared(options);
     return PermitUtils.sign(permit, publicClient, walletClient);
   },
 

package/permits/sealing.test.ts

@@ -67,7 +67,7 @@ describe('SealingKey', () => {
 
 describe('GenerateSealingKey', () => {
   it('should generate a valid SealingKey', async () => {
-    const sealingKey = await GenerateSealingKey();
+    const sealingKey = GenerateSealingKey();
 
     expect(sealingKey).toBeInstanceOf(SealingKey);
     expect(sealingKey.privateKey).toHaveLength(64);
@@ -75,8 +75,8 @@ describe('GenerateSealingKey', () => {
   });
 
   it('should generate different keys on each call', async () => {
-    const key1 = await GenerateSealingKey();
-    const key2 = await GenerateSealingKey();
+    const key1 = GenerateSealingKey();
+    const key2 = GenerateSealingKey();
 
     expect(key1.privateKey).not.toBe(key2.privateKey);
     expect(key1.publicKey).not.toBe(key2.publicKey);

package/permits/sealing.ts

@@ -122,9 +122,9 @@ export class SealingKey {
  * Asynchronously generates a new SealingKey.
  * This function uses the 'nacl' library to create a new public/private key pair for sealing purposes.
  * A sealing key is used to encrypt data such that it can only be unsealed (decrypted) by the owner of the corresponding private key.
- * @returns {Promise<SealingKey>} - A promise that resolves to a new SealingKey object containing the hexadecimal strings of the public and private keys.
+ * @returns {SealingKey} - A new SealingKey object containing the hexadecimal strings of the public and private keys.
  */
-export const GenerateSealingKey = async (): Promise<SealingKey> => {
+export const GenerateSealingKey = (): SealingKey => {
   const sodiumKeypair = nacl.box.keyPair();
 
   return new SealingKey(toHexString(sodiumKeypair.secretKey), toHexString(sodiumKeypair.publicKey));

package/permits/store.ts

@@ -15,14 +15,12 @@ type PermitsStore = {
 
 // Stores generated permits for each user, a hash indicating the active permit for each user
 // Can be used to create reactive hooks
+export const PERMIT_STORE_DEFAULTS: PermitsStore = {
+  permits: {},
+  activePermitHash: {},
+};
 export const _permitStore = createStore<PermitsStore>()(
-  persist(
-    () => ({
-      permits: {},
-      activePermitHash: {},
-    }),
-    { name: 'cofhesdk-permits' }
-  )
+  persist(() => PERMIT_STORE_DEFAULTS, { name: 'cofhesdk-permits' })
 );
 
 export const clearStaleStore = () => {

package/permits/test-utils.ts

@@ -2,7 +2,7 @@ import { type Permit, type SerializedPermit, GenerateSealingKey, PermitUtils } f
 
 // Mock permit for testing - using Bob's address as issuer
 export const createMockPermit = async (): Promise<Permit> => {
-  const sealingPair = await GenerateSealingKey();
+  const sealingPair = GenerateSealingKey();
   const serializedPermit: SerializedPermit = {
     name: 'Test Permit',
     type: 'self',

package/permits/types.ts

@@ -89,6 +89,23 @@ export interface Permit {
   _signedDomain?: EIP712Domain;
 }
 
+/**
+ * Permit discriminant helpers
+ */
+export type PermitType = Permit['type'];
+
+/**
+ * Utility type to narrow a permit to a specific discriminant.
+ *
+ * Note: this only narrows the `type` field. Runtime/validation constraints
+ * (e.g. recipient == zeroAddress for self permits) are enforced elsewhere.
+ */
+export type PermitOf<T extends PermitType> = Expand<Omit<Permit, 'type'> & { type: T }>;
+
+export type SelfPermit = PermitOf<'self'>;
+export type SharingPermit = PermitOf<'sharing'>;
+export type RecipientPermit = PermitOf<'recipient'>;
+
 /**
  * Optional additional metadata of a Permit
  * Can be passed into the constructor, but not necessary

package/permits/utils.ts

@@ -1,6 +1,5 @@
 // Utility functions for sealing key operations
 
-// eslint-disable-next-line no-unused-vars
 declare const BigInt: (value: string | number | bigint) => bigint;
 
 export const fromHexString = (hexString: string): Uint8Array => {