@cofhe/sdk 0.0.0-alpha-20260409113701

package/core/client.ts

@@ -0,0 +1,341 @@
+import type { CreateSelfPermitOptions, CreateSharingPermitOptions, ImportSharedPermitOptions } from '@/permits';
+
+import { createStore } from 'zustand/vanilla';
+import { type Hex, type PublicClient, type WalletClient } from 'viem';
+import { CofheError, CofheErrorCode } from './error.js';
+import { EncryptInputsBuilder } from './encrypt/encryptInputsBuilder.js';
+import { createKeysStore } from './keyStore.js';
+import { permits } from './permits.js';
+import { DecryptForViewBuilder } from './decrypt/decryptForViewBuilder.js';
+import { DecryptForTxBuilder, type DecryptForTxBuilderUnset } from './decrypt/decryptForTxBuilder.js';
+import { verifyDecryptResult as verifyDecryptResultStandalone } from './decrypt/verifyDecryptResult.js';
+import { getPublicClientChainID, getWalletClientAccount } from './utils.js';
+import type { CofheClientConnectionState, CofheClientParams, CofheClient, CofheClientPermits } from './clientTypes.js';
+import type { EncryptableItem, FheTypes } from './types.js';
+import type { CofheConfig } from './config.js';
+
+export const InitialConnectStore: CofheClientConnectionState = {
+  connected: false,
+  connecting: false,
+  connectError: undefined,
+  chainId: undefined,
+  account: undefined,
+  publicClient: undefined,
+  walletClient: undefined,
+};
+
+/**
+ * Creates a CoFHE client instance (base implementation)
+ * @param {CofheClientParams} opts - Initialization options including config and platform-specific serializers
+ * @returns {CofheClient} - The CoFHE client instance
+ */
+export function createCofheClientBase<TConfig extends CofheConfig>(
+  opts: CofheClientParams<TConfig>
+): CofheClient<TConfig> {
+  // Create keysStorage instance using configured storage
+  const keysStorage = createKeysStore(opts.config.fheKeyStorage);
+
+  // Zustand store for reactive state management
+
+  const connectStore = createStore<CofheClientConnectionState>(() => InitialConnectStore);
+
+  // Minimal cancellation mechanism: incremented on each connect/disconnect.
+  // If a connect finishes after a disconnect, it must not overwrite the disconnected state.
+  let connectAttemptId = 0;
+
+  // Helper to update state
+  const updateConnectState = (partial: Partial<CofheClientConnectionState>) => {
+    connectStore.setState((state) => ({ ...state, ...partial }));
+  };
+
+  // Called before any operation, throws of connection not yet established
+  const _requireConnected = () => {
+    const state = connectStore.getState();
+    const notConnected =
+      !state.connected || !state.account || !state.chainId || !state.publicClient || !state.walletClient;
+    if (notConnected) {
+      throw new CofheError({
+        code: CofheErrorCode.NotConnected,
+        message: 'Client must be connected, account and chainId must be initialized',
+        hint: 'Ensure client.connect() has been called and awaited.',
+        context: {
+          connected: state.connected,
+          account: state.account,
+          chainId: state.chainId,
+          publicClient: state.publicClient,
+          walletClient: state.walletClient,
+        },
+      });
+    }
+  };
+
+  // LIFECYCLE
+
+  async function connect(publicClient: PublicClient, walletClient: WalletClient) {
+    const state = connectStore.getState();
+
+    // Exit if already connected and clients are the same
+    if (state.connected && state.publicClient === publicClient && state.walletClient === walletClient) return;
+
+    connectAttemptId += 1;
+    const localAttemptId = connectAttemptId;
+
+    // Set connecting state
+    updateConnectState({
+      ...InitialConnectStore,
+      connecting: true,
+    });
+
+    // Fetch chainId and account
+    try {
+      const chainId = await getPublicClientChainID(publicClient);
+      const account = await getWalletClientAccount(walletClient);
+
+      // If a disconnect (or a newer connect) happened while awaiting, ignore this completion.
+      if (localAttemptId !== connectAttemptId) return;
+
+      updateConnectState({
+        connected: true,
+        connecting: false,
+        connectError: undefined,
+        chainId,
+        account,
+        publicClient,
+        walletClient,
+      });
+    } catch (e) {
+      // Ignore stale errors too.
+      if (localAttemptId !== connectAttemptId) return;
+
+      updateConnectState({
+        ...InitialConnectStore,
+        connectError: e,
+      });
+      throw e;
+    }
+  }
+
+  function disconnect() {
+    connectAttemptId += 1;
+    updateConnectState({ ...InitialConnectStore });
+  }
+
+  // CLIENT OPERATIONS
+
+  function encryptInputs<T extends EncryptableItem[]>(inputs: [...T]): EncryptInputsBuilder<[...T]> {
+    const state = connectStore.getState();
+
+    return new EncryptInputsBuilder({
+      inputs,
+      account: state.account ?? undefined,
+      chainId: state.chainId ?? undefined,
+
+      config: opts.config,
+      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,
+
+      requireConnected: _requireConnected,
+    });
+  }
+
+  function decryptForView<U extends FheTypes>(ctHash: bigint | string, utype: U): DecryptForViewBuilder<U> {
+    const state = connectStore.getState();
+
+    return new DecryptForViewBuilder({
+      ctHash,
+      utype,
+      chainId: state.chainId,
+      account: state.account,
+
+      config: opts.config,
+      publicClient: state.publicClient,
+      walletClient: state.walletClient,
+
+      requireConnected: _requireConnected,
+    });
+  }
+
+  function decryptForTx(ctHash: bigint | string): DecryptForTxBuilderUnset {
+    const state = connectStore.getState();
+
+    return new DecryptForTxBuilder({
+      ctHash,
+      chainId: state.chainId,
+      account: state.account,
+
+      config: opts.config,
+      publicClient: state.publicClient,
+      walletClient: state.walletClient,
+
+      requireConnected: _requireConnected,
+    });
+  }
+
+  // VERIFY DECRYPT RESULT
+  function verifyDecryptResult(handle: bigint | string, cleartext: bigint, signature: Hex): Promise<boolean> {
+    _requireConnected();
+    const { publicClient } = connectStore.getState();
+    return verifyDecryptResultStandalone(handle, cleartext, signature, publicClient!);
+  }
+
+  // PERMITS - Context-aware wrapper
+
+  const _getChainIdAndAccount = (chainId?: number, account?: string) => {
+    const state = connectStore.getState();
+    const _chainId = chainId ?? state.chainId;
+    const _account = account ?? state.account;
+
+    if (_chainId == null || _account == null) {
+      throw new CofheError({
+        code: CofheErrorCode.NotConnected,
+        message: 'ChainId or account not available.',
+        hint: 'Ensure client.connect() has been called, or provide chainId and account explicitly.',
+        context: {
+          chainId: _chainId,
+          account: _account,
+        },
+      });
+    }
+
+    return { chainId: _chainId, account: _account };
+  };
+
+  const clientPermits: CofheClientPermits = {
+    // Pass through store access
+    getSnapshot: permits.getSnapshot,
+    subscribe: permits.subscribe,
+
+    // Creation methods (require connection)
+    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: (hash: string, chainId?: number, account?: string) => {
+      const { chainId: _chainId, account: _account } = _getChainIdAndAccount(chainId, account);
+      return permits.getPermit(_chainId, _account, hash);
+    },
+
+    getPermits: (chainId?: number, account?: string) => {
+      const { chainId: _chainId, account: _account } = _getChainIdAndAccount(chainId, account);
+      return permits.getPermits(_chainId, _account);
+    },
+
+    getActivePermit: (chainId?: number, account?: string) => {
+      const { chainId: _chainId, account: _account } = _getChainIdAndAccount(chainId, account);
+      return permits.getActivePermit(_chainId, _account);
+    },
+
+    getActivePermitHash: (chainId?: number, account?: string) => {
+      const { chainId: _chainId, account: _account } = _getChainIdAndAccount(chainId, account);
+      return permits.getActivePermitHash(_chainId, _account);
+    },
+
+    // Mutation methods (auto-fill 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) => {
+      const { chainId: _chainId, account: _account } = _getChainIdAndAccount(chainId, account);
+      return permits.removePermit(_chainId, _account, hash);
+    },
+
+    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,
+    serialize: permits.serialize,
+    deserialize: permits.deserialize,
+  };
+
+  return {
+    // Zustand reactive accessors (don't export store directly to prevent mutation)
+    getSnapshot: connectStore.getState,
+    subscribe: connectStore.subscribe,
+
+    // flags (read-only: reflect snapshot)
+    get connection() {
+      return connectStore.getState();
+    },
+    get connected() {
+      return connectStore.getState().connected;
+    },
+    get connecting() {
+      return connectStore.getState().connecting;
+    },
+
+    // config & platform-specific (read-only)
+    config: opts.config,
+
+    connect,
+    disconnect,
+    encryptInputs,
+    decryptForView,
+    /**
+     * @deprecated Use `decryptForView` instead. Kept for backward compatibility.
+     */
+    decryptHandle: decryptForView,
+    decryptForTx,
+    verifyDecryptResult,
+    permits: clientPermits,
+
+    // Add SDK-specific methods below that require connection
+    // Example:
+    // async encryptData(data: unknown) {
+    //   requireConnected();
+    //   // Use state.publicClient and state.walletClient for implementation
+    // },
+  };
+}

package/core/clientTypes.ts

@@ -0,0 +1,119 @@
+// TODO: Extract client types to its own file, keep this one as primitives
+import { type Hex, type PublicClient, type WalletClient } from 'viem';
+import { type CofheConfig } from './config.js';
+import { type DecryptForViewBuilder } from './decrypt/decryptForViewBuilder.js';
+import { type DecryptForTxBuilderUnset } from './decrypt/decryptForTxBuilder.js';
+import { type EncryptInputsBuilder } from './encrypt/encryptInputsBuilder.js';
+import { type ZkBuilderAndCrsGenerator, type ZkProveWorkerFunction } from './encrypt/zkPackProveVerify.js';
+import { type FheKeyDeserializer } from './fetchKeys.js';
+import { permits } from './permits.js';
+import type { EncryptableItem, FheTypes, TfheInitializer } from './types.js';
+import type { PermitUtils } from 'permits/permit.js';
+import type {
+  CreateSelfPermitOptions,
+  Permit,
+  CreateSharingPermitOptions,
+  ImportSharedPermitOptions,
+  SharingPermit,
+  RecipientPermit,
+  SelfPermit,
+} from 'permits/types.js';
+
+// CLIENT
+
+export type CofheClient<TConfig extends CofheConfig = CofheConfig> = {
+  // --- state access ---
+  getSnapshot(): CofheClientConnectionState;
+  subscribe(listener: Listener): () => void;
+
+  // --- convenience flags (read-only) ---
+  readonly connection: CofheClientConnectionState;
+  readonly connected: boolean;
+  readonly connecting: boolean;
+
+  // --- config & platform-specific ---
+  readonly config: TConfig;
+
+  connect(publicClient: PublicClient, walletClient: WalletClient): Promise<void>;
+  /**
+   * Clears the current connection state (account/chainId/clients) and marks the client as disconnected.
+   *
+   * This does not delete persisted permits or stored FHE keys; it only resets the in-memory connection.
+   */
+  disconnect(): void;
+  /**
+   * Types docstring
+   */
+  encryptInputs<T extends EncryptableItem[]>(inputs: [...T]): EncryptInputsBuilder<[...T]>;
+  /**
+   * @deprecated Use `decryptForView` instead. Kept for backward compatibility.
+   */
+  decryptHandle<U extends FheTypes>(ctHash: bigint | string, utype: U): DecryptForViewBuilder<U>;
+  decryptForView<U extends FheTypes>(ctHash: bigint | string, utype: U): DecryptForViewBuilder<U>;
+  decryptForTx(ctHash: bigint | string): DecryptForTxBuilderUnset;
+  verifyDecryptResult(handle: bigint | string, cleartext: bigint, signature: Hex): Promise<boolean>;
+  permits: CofheClientPermits;
+};
+
+export type CofheClientConnectionState = {
+  connected: boolean;
+  connecting: boolean;
+  connectError: unknown | undefined;
+  chainId: number | undefined;
+  account: `0x${string}` | undefined;
+  publicClient: PublicClient | undefined;
+  walletClient: WalletClient | undefined;
+};
+
+type Listener = (snapshot: CofheClientConnectionState) => void;
+
+export type CofheClientPermitsClients = {
+  publicClient: PublicClient;
+  walletClient: WalletClient;
+};
+
+export type CofheClientPermits = {
+  getSnapshot: typeof permits.getSnapshot;
+  subscribe: typeof permits.subscribe;
+
+  // Creation methods (require connection, no params)
+  createSelf: (options: CreateSelfPermitOptions, clients?: CofheClientPermitsClients) => Promise<SelfPermit>;
+  createSharing: (options: CreateSharingPermitOptions, clients?: CofheClientPermitsClients) => Promise<SharingPermit>;
+  importShared: (
+    options: ImportSharedPermitOptions | string,
+    clients?: CofheClientPermitsClients
+  ) => Promise<RecipientPermit>;
+
+  // Retrieval methods (chainId/account optional)
+  getPermit: (hash: string, chainId?: number, account?: string) => Permit | undefined;
+  getPermits: (chainId?: number, account?: string) => Record<string, Permit>;
+  getActivePermit: (chainId?: number, account?: string) => Permit | undefined;
+  getActivePermitHash: (chainId?: number, account?: string) => string | undefined;
+
+  // Get or create methods (get active or create new, chainId/account optional)
+  getOrCreateSelfPermit: (chainId?: number, account?: string, options?: CreateSelfPermitOptions) => Promise<Permit>;
+  getOrCreateSharingPermit: (
+    options: CreateSharingPermitOptions,
+    chainId?: number,
+    account?: string
+  ) => Promise<Permit>;
+
+  // Mutation methods (chainId/account optional)
+  selectActivePermit: (hash: string, chainId?: number, account?: string) => void;
+  removePermit: (hash: string, chainId?: number, account?: string) => void;
+  removeActivePermit: (chainId?: number, account?: string) => void;
+
+  // Utils
+  getHash: typeof PermitUtils.getHash;
+  serialize: typeof PermitUtils.serialize;
+  deserialize: typeof PermitUtils.deserialize;
+};
+
+export type CofheClientParams<TConfig extends CofheConfig> = {
+  config: TConfig;
+  zkBuilderAndCrsGenerator: ZkBuilderAndCrsGenerator;
+  tfhePublicKeyDeserializer: FheKeyDeserializer;
+  compactPkeCrsDeserializer: FheKeyDeserializer;
+  initTfhe: TfheInitializer;
+  zkProveWorkerFn?: ZkProveWorkerFunction;
+};

package/core/config.test.ts

@@ -0,0 +1,242 @@
+import { sepolia, hardhat } from '@/chains';
+
+import { describe, it, expect, vi } from 'vitest';
+import {
+  createCofheConfigBase,
+  getCofheConfigItem,
+  type CofheInputConfig,
+  getSupportedChainOrThrow,
+  getCoFheUrlOrThrow,
+  getZkVerifierUrlOrThrow,
+  getThresholdNetworkUrlOrThrow,
+} from './config.js';
+
+describe('createCofheConfigBase', () => {
+  const validBaseConfig: CofheInputConfig = {
+    supportedChains: [],
+  };
+
+  const setNestedValue = (obj: any, path: string, value: any): void => {
+    const keys = path.split('.');
+    const lastKey = keys.pop()!;
+    const target = keys.reduce((acc, key) => {
+      if (!acc[key]) acc[key] = {};
+      return acc[key];
+    }, obj);
+    target[lastKey] = value;
+  };
+
+  const getNestedValue = (obj: any, path: string): any => {
+    return path.split('.').reduce((acc, key) => acc?.[key], obj);
+  };
+
+  const expectInvalidConfigItem = (path: string, value: any, log = false): void => {
+    const config = { ...validBaseConfig };
+    setNestedValue(config, path, value);
+    if (log) {
+      console.log('expect config invalid', path, value, config);
+      try {
+        createCofheConfigBase(config as CofheInputConfig);
+      } catch (e) {
+        console.log('expect config invalid', path, value, config, e);
+      }
+    }
+    expect(() => createCofheConfigBase(config as CofheInputConfig)).toThrow('Invalid cofhe configuration:');
+  };
+
+  const expectValidConfigItem = (path: string, value: any, expectedValue: any): void => {
+    const config = { ...validBaseConfig };
+    setNestedValue(config, path, value);
+    const result = createCofheConfigBase(config);
+    expect(getNestedValue(result, path)).toEqual(expectedValue);
+  };
+
+  it('environment', () => {
+    expectInvalidConfigItem('environment', 'not-a-valid-environment');
+    expectInvalidConfigItem('environment', 123);
+    expectInvalidConfigItem('environment', {});
+
+    expectValidConfigItem('environment', 'node', 'node');
+    expectValidConfigItem('environment', 'hardhat', 'hardhat');
+    expectValidConfigItem('environment', 'web', 'web');
+    expectValidConfigItem('environment', 'react', 'react');
+  });
+
+  it('supportedChains', () => {
+    expectInvalidConfigItem('supportedChains', {});
+    expectInvalidConfigItem('supportedChains', 'not-an-array');
+    expectInvalidConfigItem('supportedChains', null);
+    expectInvalidConfigItem('supportedChains', undefined);
+
+    expectValidConfigItem('supportedChains', [sepolia], [sepolia]);
+    expectValidConfigItem('supportedChains', [sepolia, hardhat], [sepolia, hardhat]);
+  });
+
+  it('defaultPermitExpiration', () => {
+    expectInvalidConfigItem('defaultPermitExpiration', 'not-a-number');
+    expectInvalidConfigItem('defaultPermitExpiration', null);
+
+    expectValidConfigItem('defaultPermitExpiration', 5, 5);
+    expectValidConfigItem('defaultPermitExpiration', undefined, 60 * 60 * 24 * 30);
+  });
+
+  it('fheKeyStorage', async () => {
+    expectInvalidConfigItem('fheKeyStorage', 'not-an-object');
+
+    expectValidConfigItem('fheKeyStorage', undefined, null);
+    expectValidConfigItem('fheKeyStorage', null, null);
+
+    let getItemCalled = false;
+    let setItemCalled = false;
+    let removeItemCalled = false;
+
+    const fakeStorage = {
+      getItem: (name: string) => {
+        getItemCalled = true;
+        return Promise.resolve(null);
+      },
+      setItem: (name: string, value: any) => {
+        setItemCalled = true;
+        return Promise.resolve();
+      },
+      removeItem: (name: string) => {
+        removeItemCalled = true;
+        return Promise.resolve();
+      },
+    };
+
+    const config = { ...validBaseConfig, fheKeyStorage: fakeStorage };
+    const result = createCofheConfigBase(config);
+
+    expect(result.fheKeyStorage).not.toBeNull();
+    await result.fheKeyStorage!.getItem('test');
+    await result.fheKeyStorage!.setItem('test', 'test');
+    await result.fheKeyStorage!.removeItem('test');
+
+    expect(getItemCalled).toBe(true);
+    expect(setItemCalled).toBe(true);
+    expect(removeItemCalled).toBe(true);
+
+    const invalidStorageNotAFunction = {
+      getItem: 'not-a-function',
+      setItem: 'not-a-function',
+      removeItem: 'not-a-function',
+    };
+
+    expectInvalidConfigItem('fheKeyStorage', invalidStorageNotAFunction);
+  });
+
+  it('mocks', () => {
+    expectInvalidConfigItem('mocks', 'not-an-object');
+    expectInvalidConfigItem('mocks', null);
+  });
+
+  it('mocks.decryptDelay', () => {
+    expectInvalidConfigItem('mocks.decryptDelay', 'not-a-number');
+    expectInvalidConfigItem('mocks.decryptDelay', null);
+
+    expectValidConfigItem('mocks.decryptDelay', undefined, 0);
+    expectValidConfigItem('mocks.decryptDelay', 1000, 1000);
+  });
+
+  it('mocks.encryptDelay', () => {
+    expectInvalidConfigItem('mocks.encryptDelay', 'not-a-number');
+    expectInvalidConfigItem('mocks.encryptDelay', null);
+    expectInvalidConfigItem('mocks.encryptDelay', [100, 100, 100]); // wrong tuple length
+    expectInvalidConfigItem('mocks.encryptDelay', ['a', 'b', 'c', 'd', 'e']); // non-number elements
+
+    expectValidConfigItem('mocks.encryptDelay', undefined, [100, 100, 100, 500, 500]);
+    expectValidConfigItem('mocks.encryptDelay', 200, 200);
+    expectValidConfigItem('mocks.encryptDelay', 0, 0);
+    expectValidConfigItem('mocks.encryptDelay', [10, 20, 30, 40, 50], [10, 20, 30, 40, 50]);
+  });
+
+  it('useWorkers', () => {
+    expectInvalidConfigItem('useWorkers', 'not-a-boolean');
+    expectInvalidConfigItem('useWorkers', null);
+    expectInvalidConfigItem('useWorkers', 123);
+    expectInvalidConfigItem('useWorkers', {});
+
+    expectValidConfigItem('useWorkers', true, true);
+    expectValidConfigItem('useWorkers', false, false);
+    expectValidConfigItem('useWorkers', undefined, true); // defaults to true
+  });
+
+  it('should get config item', () => {
+    const config: CofheInputConfig = {
+      supportedChains: [sepolia],
+    };
+
+    const result = createCofheConfigBase(config);
+
+    const supportedChains = getCofheConfigItem(result, 'supportedChains');
+    expect(supportedChains).toEqual(config.supportedChains);
+  });
+});
+
+describe('Config helper functions', () => {
+  const config = createCofheConfigBase({
+    supportedChains: [sepolia, hardhat],
+  });
+
+  describe('getSupportedChainOrThrow', () => {
+    it('should return chain when found', () => {
+      expect(getSupportedChainOrThrow(config, sepolia.id)).toEqual(sepolia);
+    });
+
+    it('should throw UnsupportedChain error when not found', () => {
+      expect(() => getSupportedChainOrThrow(config, 999999)).toThrow();
+    });
+  });
+
+  describe('getCoFheUrlOrThrow', () => {
+    it('should return coFheUrl', () => {
+      expect(getCoFheUrlOrThrow(config, sepolia.id)).toBe(sepolia.coFheUrl);
+    });
+
+    it('should throw when chain not found', () => {
+      expect(() => getCoFheUrlOrThrow(config, 999999)).toThrow();
+    });
+
+    it('should throw MissingConfig when url not set', () => {
+      const configWithoutUrl = createCofheConfigBase({
+        supportedChains: [{ ...sepolia, coFheUrl: undefined } as any],
+      });
+      expect(() => getCoFheUrlOrThrow(configWithoutUrl, sepolia.id)).toThrow();
+    });
+  });
+
+  describe('getZkVerifierUrlOrThrow', () => {
+    it('should return verifierUrl', () => {
+      expect(getZkVerifierUrlOrThrow(config, sepolia.id)).toBe(sepolia.verifierUrl);
+    });
+
+    it('should throw when chain not found', () => {
+      expect(() => getZkVerifierUrlOrThrow(config, 999999)).toThrow();
+    });
+
+    it('should throw ZkVerifierUrlUninitialized when url not set', () => {
+      const configWithoutUrl = createCofheConfigBase({
+        supportedChains: [{ ...sepolia, verifierUrl: undefined } as any],
+      });
+      expect(() => getZkVerifierUrlOrThrow(configWithoutUrl, sepolia.id)).toThrow();
+    });
+  });
+
+  describe('getThresholdNetworkUrlOrThrow', () => {
+    it('should return thresholdNetworkUrl', () => {
+      expect(getThresholdNetworkUrlOrThrow(config, sepolia.id)).toBe(sepolia.thresholdNetworkUrl);
+    });
+
+    it('should throw when chain not found', () => {
+      expect(() => getThresholdNetworkUrlOrThrow(config, 999999)).toThrow();
+    });
+
+    it('should throw ThresholdNetworkUrlUninitialized when url not set', () => {
+      const configWithoutUrl = createCofheConfigBase({
+        supportedChains: [{ ...sepolia, thresholdNetworkUrl: undefined } as any],
+      });
+      expect(() => getThresholdNetworkUrlOrThrow(configWithoutUrl, sepolia.id)).toThrow();
+    });
+  });
+});