@cofhe/sdk 0.1.1 → 0.2.0

package/core/client.test.ts

@@ -1,8 +1,8 @@
 import { describe, it, expect, vi, beforeEach } from 'vitest';
 import { createCofhesdkClientBase } from './client.js';
-import { type CofhesdkClient, type CofhesdkClientConnectionState } from './types.js';
-import { createCofhesdkConfigBase } from './config.js';
-import { CofhesdkErrorCode } from './error.js';
+import { type CofhesdkClient, type CofhesdkClientConnectionState } from './clientTypes.js';
+import { createCofhesdkConfigBase, type CofhesdkEnvironment } from './config.js';
+import { CofhesdkError, CofhesdkErrorCode } from './error.js';
 import { type PublicClient, type WalletClient } from 'viem';
 import { EncryptInputsBuilder } from './encrypt/encryptInputsBuilder.js';
 import { Encryptable } from './types.js';
@@ -20,10 +20,6 @@ vi.mock('./keyStore', () => ({
   })),
 }));
 
-vi.mock('./fetchKeys', () => ({
-  fetchMultichainKeys: vi.fn().mockResolvedValue(undefined),
-}));
-
 // Test helpers
 const createMockPublicClient = (chainId = 11155111): PublicClient =>
   ({
@@ -61,6 +57,8 @@ describe('createCofhesdkClientBase', () => {
       expect(snapshot.connectError).toBe(undefined);
       expect(snapshot.chainId).toBe(undefined);
       expect(snapshot.account).toBe(undefined);
+      expect(snapshot.publicClient).toBe(undefined);
+      expect(snapshot.walletClient).toBe(undefined);
     });
 
     it('should expose convenience flags', () => {
@@ -74,6 +72,24 @@ describe('createCofhesdkClientBase', () => {
     });
   });
 
+  describe('environment', () => {
+    it('should create a client with the correct environment', async () => {
+      const environments: CofhesdkEnvironment[] = ['node', 'hardhat', 'web', 'react'];
+      for (const environment of environments) {
+        const config = createCofhesdkConfigBase({ environment, supportedChains: [] });
+        const client = createCofhesdkClientBase({
+          config,
+          zkBuilderAndCrsGenerator: {} as any,
+          tfhePublicKeyDeserializer: {} as any,
+          compactPkeCrsDeserializer: {} as any,
+          initTfhe: () => Promise.resolve(false),
+        });
+
+        expect(client.config.environment).toBe(environment);
+      }
+    });
+  });
+
   describe('reactive state', () => {
     it('should notify subscribers of state changes', async () => {
       const states: CofhesdkClientConnectionState[] = [];
@@ -88,12 +104,16 @@ describe('createCofhesdkClientBase', () => {
       expect(states[0].connected).toBe(false);
       expect(states[0].chainId).toBe(undefined);
       expect(states[0].account).toBe(undefined);
+      expect(states[0].publicClient).toBe(undefined);
+      expect(states[0].walletClient).toBe(undefined);
 
       // Expect states[1] to be the connected state
       expect(states[1].connected).toBe(true);
       expect(states[1].connecting).toBe(false);
       expect(states[1].chainId).toBe(11155111);
       expect(states[1].account).toBe('0x1234567890123456789012345678901234567890');
+      expect(states[1].publicClient).toBe(publicClient);
+      expect(states[1].walletClient).toBe(walletClient);
     });
 
     it('should stop notifications after unsubscribe', async () => {
@@ -116,10 +136,7 @@ describe('createCofhesdkClientBase', () => {
       const publicClient = createMockPublicClient(11155111);
       const walletClient = createMockWalletClient(['0xabcd']);
 
-      const result = await client.connect(publicClient, walletClient);
-
-      expect(result.success).toBe(true);
-      expect(result.data).toBe(true);
+      await client.connect(publicClient, walletClient);
 
       expect(client.connected).toBe(true);
       expect(client.connecting).toBe(false);
@@ -127,6 +144,8 @@ describe('createCofhesdkClientBase', () => {
       const snapshot = client.getSnapshot();
       expect(snapshot.chainId).toBe(11155111);
       expect(snapshot.account).toBe('0xabcd');
+      expect(snapshot.publicClient).toBe(publicClient);
+      expect(snapshot.walletClient).toBe(walletClient);
     });
 
     it('should set connecting state during connection', async () => {
@@ -157,95 +176,104 @@ describe('createCofhesdkClientBase', () => {
       await promise1;
     });
 
-    it('should return immediately if already connected with same clients', async () => {
+    it('should handle publicClient.getChainId throwing an error', async () => {
       const publicClient = createMockPublicClient();
+      const getChainIdError = new Error('Network error');
+      publicClient.getChainId = vi.fn().mockRejectedValue(getChainIdError);
       const walletClient = createMockWalletClient();
 
-      await client.connect(publicClient, walletClient);
-      const result = await client.connect(publicClient, walletClient);
-
-      expect(result.success).toBe(true);
-    });
-
-    it('should handle getChainId throwing an error', async () => {
-      const publicClient = createMockPublicClient();
-      const error = new Error('Network error');
-      publicClient.getChainId = vi.fn().mockRejectedValue(error);
-      const walletClient = createMockWalletClient();
-
-      const result = await client.connect(publicClient, walletClient);
-
-      expect(result.success).toBe(false);
-      expect(result.error?.code).toBe(CofhesdkErrorCode.PublicWalletGetChainIdFailed);
-      expect(result.error?.message).toBe('getting chain ID from public client failed | Caused by: Network error');
-      expect(result.error?.cause).toBe(error);
-      expect(client.connected).toBe(false);
+      try {
+        await client.connect(publicClient, walletClient);
+      } catch (error) {
+        expect(error).toBeInstanceOf(CofhesdkError);
+        expect((error as CofhesdkError).code).toBe(CofhesdkErrorCode.PublicWalletGetChainIdFailed);
+        expect((error as CofhesdkError).message).toBe(
+          'getting chain ID from public client failed | Caused by: Network error'
+        );
+        expect((error as CofhesdkError).cause).toBe(getChainIdError);
+      }
     });
 
-    it('should handle getChainId returning null', async () => {
+    it('should handle publicClient.getChainId returning null', async () => {
       const publicClient = createMockPublicClient();
       publicClient.getChainId = vi.fn().mockResolvedValue(null);
       const walletClient = createMockWalletClient();
 
-      const result = await client.connect(publicClient, walletClient);
+      const connectPromise = client.connect(publicClient, walletClient);
 
-      expect(result.success).toBe(false);
-      expect(result.error?.code).toBe(CofhesdkErrorCode.PublicWalletGetChainIdFailed);
-      expect(result.error?.message).toBe('chain ID from public client is null');
-      expect(result.error?.cause).toBe(undefined);
-      expect(client.connected).toBe(false);
+      try {
+        await connectPromise;
+      } catch (error) {
+        expect(error).toBeInstanceOf(CofhesdkError);
+        expect((error as CofhesdkError).code).toBe(CofhesdkErrorCode.PublicWalletGetChainIdFailed);
+        expect((error as CofhesdkError).message).toBe('chain ID from public client is null');
+      }
     });
 
-    it('should handle getAddresses throwing an error', async () => {
+    it('should handle walletClient.getAddresses throwing an error', async () => {
       const publicClient = createMockPublicClient();
-      const error = new Error('Network error');
+      const getAddressesError = new Error('Network error');
       const walletClient = createMockWalletClient();
-      walletClient.getAddresses = vi.fn().mockRejectedValue(error);
+      walletClient.getAddresses = vi.fn().mockRejectedValue(getAddressesError);
 
-      const result = await client.connect(publicClient, walletClient);
+      const connectPromise = client.connect(publicClient, walletClient);
 
-      expect(result.success).toBe(false);
-      expect(result.error?.code).toBe(CofhesdkErrorCode.PublicWalletGetAddressesFailed);
-      expect(result.error?.message).toBe('getting address from wallet client failed | Caused by: Network error');
-      expect(result.error?.cause).toBe(error);
-      expect(client.connected).toBe(false);
+      try {
+        await connectPromise;
+      } catch (error) {
+        expect(error).toBeInstanceOf(CofhesdkError);
+        expect((error as CofhesdkError).code).toBe(CofhesdkErrorCode.PublicWalletGetAddressesFailed);
+        expect((error as CofhesdkError).message).toBe(
+          'getting address from wallet client failed | Caused by: Network error'
+        );
+        expect((error as CofhesdkError).cause).toBe(getAddressesError);
+      }
     });
 
-    it('should handle getAddresses returning an empty array', async () => {
+    it('should handle walletClient.getAddresses returning an empty array', async () => {
       const publicClient = createMockPublicClient();
       const walletClient = createMockWalletClient([]);
 
-      const result = await client.connect(publicClient, walletClient);
+      const connectPromise = client.connect(publicClient, walletClient);
 
-      expect(result.success).toBe(false);
-      expect(result.error?.code).toBe(CofhesdkErrorCode.PublicWalletGetAddressesFailed);
-      expect(result.error?.message).toBe('address from wallet client is null');
-      expect(result.error?.cause).toBe(undefined);
-      expect(client.connected).toBe(false);
+      try {
+        await connectPromise;
+      } catch (error) {
+        expect(error).toBeInstanceOf(CofhesdkError);
+        expect((error as CofhesdkError).code).toBe(CofhesdkErrorCode.PublicWalletGetAddressesFailed);
+        expect((error as CofhesdkError).message).toBe('address from wallet client is null');
+      }
     });
 
     it('should store error in state on failure', async () => {
       const publicClient = createMockPublicClient();
-      const error = new Error('Network error');
-      publicClient.getChainId = vi.fn().mockRejectedValue(error);
+      const getChainIdError = new Error('Network error');
+      publicClient.getChainId = vi.fn().mockRejectedValue(getChainIdError);
       const walletClient = createMockWalletClient();
 
-      const result = await client.connect(publicClient, walletClient);
+      const connectPromise = client.connect(publicClient, walletClient);
 
-      expect(result.success).toBe(false);
-      const snapshot = client.getSnapshot();
-      expect(snapshot.connectError).toBeTruthy();
-      expect(snapshot.connected).toBe(false);
+      try {
+        await connectPromise;
+      } catch (error) {
+        expect(error).toBeInstanceOf(CofhesdkError);
+        expect((error as CofhesdkError).code).toBe(CofhesdkErrorCode.PublicWalletGetChainIdFailed);
+        expect((error as CofhesdkError).message).toBe(
+          'getting chain ID from public client failed | Caused by: Network error'
+        );
+        expect((error as CofhesdkError).cause).toBe(getChainIdError);
+      }
     });
   });
 
   describe('encryptInputs', () => {
     it('should throw if not connected', async () => {
-      const result = await client
-        .encryptInputs([Encryptable.uint8(1n), Encryptable.uint8(2n), Encryptable.uint8(3n)])
-        .encrypt();
-      expect(result.success).toBe(false);
-      expect(result.error?.code).toBe(CofhesdkErrorCode.NotConnected);
+      try {
+        await client.encryptInputs([Encryptable.uint8(1n), Encryptable.uint8(2n), Encryptable.uint8(3n)]).encrypt();
+      } catch (error) {
+        expect(error).toBeInstanceOf(CofhesdkError);
+        expect((error as CofhesdkError).code).toBe(CofhesdkErrorCode.NotConnected);
+      }
     });
 
     it('should create EncryptInputsBuilder when connected', async () => {
@@ -264,17 +292,6 @@ describe('createCofhesdkClientBase', () => {
     });
   });
 
-  describe('initializationResults', () => {
-    it('should have keyFetchResult promise', () => {
-      expect(client.initializationResults.keyFetchResult).toBeInstanceOf(Promise);
-    });
-
-    it('should resolve keyFetchResult', async () => {
-      const result = await client.initializationResults.keyFetchResult;
-      expect(result.success).toBe(true);
-    });
-  });
-
   describe('permits', () => {
     it('should expose permits', () => {
       expect(client.permits).toBeDefined();

package/core/client.ts

@@ -1,59 +1,57 @@
-/* eslint-disable no-unused-vars */
 import type { CreateSelfPermitOptions, CreateSharingPermitOptions, ImportSharedPermitOptions } from '@/permits';
 
 import { createStore } from 'zustand/vanilla';
 import { type PublicClient, type WalletClient } from 'viem';
-import { fetchMultichainKeys } from './fetchKeys.js';
 import { CofhesdkError, CofhesdkErrorCode } from './error.js';
 import { EncryptInputsBuilder } from './encrypt/encryptInputsBuilder.js';
-import { type Result, ResultOk, resultWrapper } from './result.js';
 import { createKeysStore } from './keyStore.js';
 import { permits } from './permits.js';
 import { DecryptHandlesBuilder } from './decrypt/decryptHandleBuilder.js';
-import {
-  type CofhesdkClient,
-  type CofhesdkClientParams,
-  type CofhesdkClientConnectionState,
-  type EncryptableItem,
-  type FheTypes,
-  type CofhesdkClientPermits,
-} from './types.js';
 import { getPublicClientChainID, getWalletClientAccount } from './utils.js';
+import type {
+  CofhesdkClientConnectionState,
+  CofhesdkClientParams,
+  CofhesdkClient,
+  CofhesdkClientPermits,
+} from './clientTypes.js';
+import type { EncryptableItem, FheTypes } from './types.js';
+import type { CofhesdkConfig } from './config.js';
+
+export const InitialConnectStore: CofhesdkClientConnectionState = {
+  connected: false,
+  connecting: false,
+  connectError: undefined,
+  chainId: undefined,
+  account: undefined,
+  publicClient: undefined,
+  walletClient: undefined,
+};
 
 /**
  * Creates a CoFHE SDK client instance (base implementation)
  * @param {CofhesdkClientParams} opts - Initialization options including config and platform-specific serializers
  * @returns {CofhesdkClient} - The CoFHE SDK client instance
  */
-export function createCofhesdkClientBase(opts: CofhesdkClientParams): CofhesdkClient {
+export function createCofhesdkClientBase<TConfig extends CofhesdkConfig>(
+  opts: CofhesdkClientParams<TConfig>
+): CofhesdkClient<TConfig> {
   // Create keysStorage instance using configured storage
   const keysStorage = createKeysStore(opts.config.fheKeyStorage);
 
-  // refs captured in closure
-  let _publicClient: PublicClient | undefined = undefined;
-  let _walletClient: WalletClient | undefined = undefined;
-
   // Zustand store for reactive state management
-  const connectStore = createStore<CofhesdkClientConnectionState>(() => ({
-    connected: false,
-    connecting: false,
-    connectError: undefined,
-    chainId: undefined,
-    account: undefined,
-  }));
+
+  const connectStore = createStore<CofhesdkClientConnectionState>(() => InitialConnectStore);
 
   // Helper to update state
   const updateConnectState = (partial: Partial<CofhesdkClientConnectionState>) => {
     connectStore.setState((state) => ({ ...state, ...partial }));
   };
 
-  // single-flight + abortable warmup
-  let _connectPromise: Promise<Result<boolean>> | undefined = undefined;
-
   // Called before any operation, throws of connection not yet established
   const _requireConnected = () => {
     const state = connectStore.getState();
-    const notConnected = !state.connected || !_publicClient || !_walletClient || !state.account || !state.chainId;
+    const notConnected =
+      !state.connected || !state.account || !state.chainId || !state.publicClient || !state.walletClient;
     if (notConnected) {
       throw new CofhesdkError({
         code: CofhesdkErrorCode.NotConnected,
@@ -63,74 +61,47 @@ export function createCofhesdkClientBase(opts: CofhesdkClientParams): CofhesdkCl
           connected: state.connected,
           account: state.account,
           chainId: state.chainId,
-          publicClient: _publicClient,
-          walletClient: _walletClient,
+          publicClient: state.publicClient,
+          walletClient: state.walletClient,
         },
       });
     }
   };
 
-  // INITIALIZATION
-
-  const keyFetchResult = resultWrapper(async () => {
-    // If configured, fetch keys for all supported chains
-    if (opts.config.fheKeysPrefetching === 'SUPPORTED_CHAINS') {
-      await fetchMultichainKeys(
-        opts.config,
-        0,
-        opts.tfhePublicKeyDeserializer,
-        opts.compactPkeCrsDeserializer,
-        keysStorage
-      );
-      return true;
-    }
-
-    return false;
-  });
-
   // LIFECYCLE
 
   async function connect(publicClient: PublicClient, walletClient: WalletClient) {
     const state = connectStore.getState();
 
     // Exit if already connected and clients are the same
-    if (state.connected && _publicClient === publicClient && _walletClient === walletClient) {
-      return Promise.resolve(ResultOk(true));
-    }
-
-    // Exit if already connecting
-    if (_connectPromise && _publicClient === publicClient && _walletClient === walletClient) {
-      return _connectPromise;
-    }
+    if (state.connected && state.publicClient === publicClient && state.walletClient === walletClient) return;
 
     // Set connecting state
-    updateConnectState({ connecting: true, connectError: null, connected: false });
-
-    _connectPromise = resultWrapper(
-      // try
-      async () => {
-        _publicClient = publicClient;
-        _walletClient = walletClient;
-
-        const chainId = await getPublicClientChainID(publicClient);
-        const account = await getWalletClientAccount(walletClient);
-
-        updateConnectState({ connecting: false, connected: true, chainId, account });
-
-        return true;
-      },
-      // catch
-      (e) => {
-        updateConnectState({ connecting: false, connected: false, connectError: e });
-        return false;
-      },
-      // finally
-      () => {
-        _connectPromise = undefined;
-      }
-    );
-
-    return _connectPromise;
+    updateConnectState({
+      ...InitialConnectStore,
+      connecting: true,
+    });
+
+    // Fetch chainId and account
+    try {
+      const chainId = await getPublicClientChainID(publicClient);
+      const account = await getWalletClientAccount(walletClient);
+      updateConnectState({
+        connected: true,
+        connecting: false,
+        connectError: undefined,
+        chainId,
+        account,
+        publicClient,
+        walletClient,
+      });
+    } catch (e) {
+      updateConnectState({
+        ...InitialConnectStore,
+        connectError: e,
+      });
+      throw e;
+    }
   }
 
   // CLIENT OPERATIONS
@@ -144,14 +115,15 @@ export function createCofhesdkClientBase(opts: CofhesdkClientParams): CofhesdkCl
       chainId: state.chainId ?? undefined,
 
       config: opts.config,
-      publicClient: _publicClient ?? undefined,
-      walletClient: _walletClient ?? undefined,
+      publicClient: state.publicClient ?? undefined,
+      walletClient: state.walletClient ?? undefined,
       zkvWalletClient: opts.config._internal?.zkvWalletClient,
 
       tfhePublicKeyDeserializer: opts.tfhePublicKeyDeserializer,
       compactPkeCrsDeserializer: opts.compactPkeCrsDeserializer,
       zkBuilderAndCrsGenerator: opts.zkBuilderAndCrsGenerator,
       initTfhe: opts.initTfhe,
+      zkProveWorkerFn: opts.zkProveWorkerFn,
 
       keysStorage,
 
@@ -169,8 +141,8 @@ export function createCofhesdkClientBase(opts: CofhesdkClientParams): CofhesdkCl
       account: state.account ?? undefined,
 
       config: opts.config,
-      publicClient: _publicClient ?? undefined,
-      walletClient: _walletClient ?? undefined,
+      publicClient: state.publicClient ?? undefined,
+      walletClient: state.walletClient ?? undefined,
 
       requireConnected: _requireConnected,
     });
@@ -204,67 +176,84 @@ export function createCofhesdkClientBase(opts: CofhesdkClientParams): CofhesdkCl
     subscribe: permits.subscribe,
 
     // Creation methods (require connection)
-    createSelf: async (options: CreateSelfPermitOptions) =>
-      resultWrapper(async () => {
-        _requireConnected();
-        return permits.createSelf(options, _publicClient!, _walletClient!);
-      }),
-
-    createSharing: async (options: CreateSharingPermitOptions) =>
-      resultWrapper(async () => {
-        _requireConnected();
-        return permits.createSharing(options, _publicClient!, _walletClient!);
-      }),
-
-    importShared: async (options: ImportSharedPermitOptions | any | string) =>
-      resultWrapper(async () => {
-        _requireConnected();
-        return permits.importShared(options, _publicClient!, _walletClient!);
-      }),
+    createSelf: async (
+      options: CreateSelfPermitOptions,
+      clients?: { publicClient: PublicClient; walletClient: WalletClient }
+    ) => {
+      _requireConnected();
+      const { publicClient, walletClient } = clients ?? connectStore.getState();
+      return permits.createSelf(options, publicClient!, walletClient!);
+    },
+
+    createSharing: async (
+      options: CreateSharingPermitOptions,
+      clients?: { publicClient: PublicClient; walletClient: WalletClient }
+    ) => {
+      _requireConnected();
+      const { publicClient, walletClient } = clients ?? connectStore.getState();
+      return permits.createSharing(options, publicClient!, walletClient!);
+    },
+
+    importShared: async (
+      options: ImportSharedPermitOptions | string,
+      clients?: { publicClient: PublicClient; walletClient: WalletClient }
+    ) => {
+      _requireConnected();
+      const { publicClient, walletClient } = clients ?? connectStore.getState();
+      return permits.importShared(options, publicClient!, walletClient!);
+    },
+
+    // Get or create methods (require connection)
+    getOrCreateSelfPermit: async (chainId?: number, account?: string, options?: CreateSelfPermitOptions) => {
+      _requireConnected();
+      const { chainId: _chainId, account: _account } = _getChainIdAndAccount(chainId, account);
+      const { publicClient, walletClient } = connectStore.getState();
+      return permits.getOrCreateSelfPermit(publicClient!, walletClient!, _chainId, _account, options);
+    },
+
+    getOrCreateSharingPermit: async (options: CreateSharingPermitOptions, chainId?: number, account?: string) => {
+      _requireConnected();
+      const { chainId: _chainId, account: _account } = _getChainIdAndAccount(chainId, account);
+      const { publicClient, walletClient } = connectStore.getState();
+      return permits.getOrCreateSharingPermit(publicClient!, walletClient!, options, _chainId, _account);
+    },
 
     // Retrieval methods (auto-fill chainId/account)
-    getPermit: async (hash: string, chainId?: number, account?: string) =>
-      resultWrapper(async () => {
-        const { chainId: _chainId, account: _account } = _getChainIdAndAccount(chainId, account);
-        return permits.getPermit(_chainId, _account, hash);
-      }),
-
-    getPermits: async (chainId?: number, account?: string) =>
-      resultWrapper(async () => {
-        const { chainId: _chainId, account: _account } = _getChainIdAndAccount(chainId, account);
-        return permits.getPermits(_chainId, _account);
-      }),
-
-    getActivePermit: async (chainId?: number, account?: string) =>
-      resultWrapper(async () => {
-        const { chainId: _chainId, account: _account } = _getChainIdAndAccount(chainId, account);
-        return permits.getActivePermit(_chainId, _account);
-      }),
-
-    getActivePermitHash: async (chainId?: number, account?: string) =>
-      resultWrapper(async () => {
-        const { chainId: _chainId, account: _account } = _getChainIdAndAccount(chainId, account);
-        return permits.getActivePermitHash(_chainId, _account);
-      }),
+    getPermit: async (hash: string, chainId?: number, account?: string) => {
+      const { chainId: _chainId, account: _account } = _getChainIdAndAccount(chainId, account);
+      return permits.getPermit(_chainId, _account, hash);
+    },
+
+    getPermits: async (chainId?: number, account?: string) => {
+      const { chainId: _chainId, account: _account } = _getChainIdAndAccount(chainId, account);
+      return permits.getPermits(_chainId, _account);
+    },
+
+    getActivePermit: async (chainId?: number, account?: string) => {
+      const { chainId: _chainId, account: _account } = _getChainIdAndAccount(chainId, account);
+      return permits.getActivePermit(_chainId, _account);
+    },
+
+    getActivePermitHash: async (chainId?: number, account?: string) => {
+      const { chainId: _chainId, account: _account } = _getChainIdAndAccount(chainId, account);
+      return permits.getActivePermitHash(_chainId, _account);
+    },
 
     // Mutation methods (auto-fill chainId/account)
-    selectActivePermit: async (hash: string, chainId?: number, account?: string) =>
-      resultWrapper(async () => {
-        const { chainId: _chainId, account: _account } = _getChainIdAndAccount(chainId, account);
-        return permits.selectActivePermit(_chainId, _account, hash);
-      }),
-
-    removePermit: async (hash: string, chainId?: number, account?: string) =>
-      resultWrapper(async () => {
-        const { chainId: _chainId, account: _account } = _getChainIdAndAccount(chainId, account);
-        return permits.removePermit(_chainId, _account, hash);
-      }),
-
-    removeActivePermit: async (chainId?: number, account?: string) =>
-      resultWrapper(async () => {
-        const { chainId: _chainId, account: _account } = _getChainIdAndAccount(chainId, account);
-        return permits.removeActivePermit(_chainId, _account);
-      }),
+    selectActivePermit: (hash: string, chainId?: number, account?: string) => {
+      const { chainId: _chainId, account: _account } = _getChainIdAndAccount(chainId, account);
+      return permits.selectActivePermit(_chainId, _account, hash);
+    },
+
+    removePermit: async (hash: string, chainId?: number, account?: string, force?: boolean) => {
+      const { chainId: _chainId, account: _account } = _getChainIdAndAccount(chainId, account);
+      return permits.removePermit(_chainId, _account, hash, force);
+    },
+
+    removeActivePermit: async (chainId?: number, account?: string) => {
+      const { chainId: _chainId, account: _account } = _getChainIdAndAccount(chainId, account);
+      return permits.removeActivePermit(_chainId, _account);
+    },
 
     // Utils (no context needed)
     getHash: permits.getHash,
@@ -277,11 +266,6 @@ export function createCofhesdkClientBase(opts: CofhesdkClientParams): CofhesdkCl
     getSnapshot: connectStore.getState,
     subscribe: connectStore.subscribe,
 
-    // initialization results
-    initializationResults: {
-      keyFetchResult,
-    },
-
     // flags (read-only: reflect snapshot)
     get connected() {
       return connectStore.getState().connected;
@@ -302,7 +286,7 @@ export function createCofhesdkClientBase(opts: CofhesdkClientParams): CofhesdkCl
     // Example:
     // async encryptData(data: unknown) {
     //   requireConnected();
-    //   // Use _publicClient and _walletClient for implementation
+    //   // Use state.publicClient and state.walletClient for implementation
     // },
   };
 }