@cofhe/sdk 0.1.0 → 0.2.0

package/core/client.ts

@@ -0,0 +1,292 @@
+import type { CreateSelfPermitOptions, CreateSharingPermitOptions, ImportSharedPermitOptions } from '@/permits';
+
+import { createStore } from 'zustand/vanilla';
+import { type PublicClient, type WalletClient } from 'viem';
+import { CofhesdkError, CofhesdkErrorCode } from './error.js';
+import { EncryptInputsBuilder } from './encrypt/encryptInputsBuilder.js';
+import { createKeysStore } from './keyStore.js';
+import { permits } from './permits.js';
+import { DecryptHandlesBuilder } from './decrypt/decryptHandleBuilder.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<TConfig extends CofhesdkConfig>(
+  opts: CofhesdkClientParams<TConfig>
+): CofhesdkClient<TConfig> {
+  // Create keysStorage instance using configured storage
+  const keysStorage = createKeysStore(opts.config.fheKeyStorage);
+
+  // Zustand store for reactive state management
+
+  const connectStore = createStore<CofhesdkClientConnectionState>(() => InitialConnectStore);
+
+  // Helper to update state
+  const updateConnectState = (partial: Partial<CofhesdkClientConnectionState>) => {
+    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 CofhesdkError({
+        code: CofhesdkErrorCode.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;
+
+    // Set connecting state
+    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
+
+  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 decryptHandle<U extends FheTypes>(ctHash: bigint, utype: U): DecryptHandlesBuilder<U> {
+    const state = connectStore.getState();
+
+    return new DecryptHandlesBuilder({
+      ctHash,
+      utype,
+      chainId: state.chainId ?? undefined,
+      account: state.account ?? undefined,
+
+      config: opts.config,
+      publicClient: state.publicClient ?? undefined,
+      walletClient: state.walletClient ?? undefined,
+
+      requireConnected: _requireConnected,
+    });
+  }
+
+  // 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 CofhesdkError({
+        code: CofhesdkErrorCode.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: CofhesdkClientPermits = {
+    // 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: 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: (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,
+    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 connected() {
+      return connectStore.getState().connected;
+    },
+    get connecting() {
+      return connectStore.getState().connecting;
+    },
+
+    // config & platform-specific (read-only)
+    config: opts.config,
+
+    connect,
+    encryptInputs,
+    decryptHandle,
+    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,108 @@
+// TODO: Extract client types to its own file, keep this one as primitives
+import { type PublicClient, type WalletClient } from 'viem';
+import { type CofhesdkConfig, type CofhesdkEnvironment } from './config.js';
+import { type DecryptHandlesBuilder } from './decrypt/decryptHandleBuilder.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 CofhesdkClient<TConfig extends CofhesdkConfig = CofhesdkConfig> = {
+  // --- state access ---
+  getSnapshot(): CofhesdkClientConnectionState;
+  subscribe(listener: Listener): () => void;
+
+  // --- convenience flags (read-only) ---
+  readonly connected: boolean;
+  readonly connecting: boolean;
+
+  // --- config & platform-specific ---
+  readonly config: TConfig;
+
+  connect(publicClient: PublicClient, walletClient: WalletClient): Promise<void>;
+  /**
+   * Types docstring
+   */
+  encryptInputs<T extends EncryptableItem[]>(inputs: [...T]): EncryptInputsBuilder<[...T]>;
+  decryptHandle<U extends FheTypes>(ctHash: bigint, utype: U): DecryptHandlesBuilder<U>;
+  permits: CofhesdkClientPermits;
+};
+
+export type CofhesdkClientConnectionState = {
+  connected: boolean;
+  connecting: boolean;
+  connectError: unknown | undefined;
+  chainId: number | undefined;
+  account: `0x${string}` | undefined;
+  publicClient: PublicClient | undefined;
+  walletClient: WalletClient | undefined;
+};
+
+type Listener = (snapshot: CofhesdkClientConnectionState) => void;
+
+export type CofhesdkClientPermitsClients = {
+  publicClient: PublicClient;
+  walletClient: WalletClient;
+};
+
+export type CofhesdkClientPermits = {
+  getSnapshot: typeof permits.getSnapshot;
+  subscribe: typeof permits.subscribe;
+
+  // Creation methods (require connection, no params)
+  createSelf: (options: CreateSelfPermitOptions, clients?: CofhesdkClientPermitsClients) => Promise<SelfPermit>;
+  createSharing: (
+    options: CreateSharingPermitOptions,
+    clients?: CofhesdkClientPermitsClients
+  ) => Promise<SharingPermit>;
+  importShared: (
+    options: ImportSharedPermitOptions | string,
+    clients?: CofhesdkClientPermitsClients
+  ) => Promise<RecipientPermit>;
+
+  // Retrieval methods (chainId/account optional)
+  getPermit: (hash: string, chainId?: number, account?: string) => Promise<Permit | undefined>;
+  getPermits: (chainId?: number, account?: string) => Promise<Record<string, Permit>>;
+  getActivePermit: (chainId?: number, account?: string) => Promise<Permit | undefined>;
+  getActivePermitHash: (chainId?: number, account?: string) => Promise<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, force?: boolean) => void;
+  removeActivePermit: (chainId?: number, account?: string) => void;
+
+  // Utils
+  getHash: typeof PermitUtils.getHash;
+  serialize: typeof PermitUtils.serialize;
+  deserialize: typeof PermitUtils.deserialize;
+};
+
+export type CofhesdkClientParams<TConfig extends CofhesdkConfig> = {
+  config: TConfig;
+  zkBuilderAndCrsGenerator: ZkBuilderAndCrsGenerator;
+  tfhePublicKeyDeserializer: FheKeyDeserializer;
+  compactPkeCrsDeserializer: FheKeyDeserializer;
+  initTfhe: TfheInitializer;
+  zkProveWorkerFn?: ZkProveWorkerFunction;
+};

package/core/config.test.ts

@@ -0,0 +1,235 @@
+import { sepolia, hardhat } from '@/chains';
+
+import { describe, it, expect, vi } from 'vitest';
+import {
+  createCofhesdkConfigBase,
+  getCofhesdkConfigItem,
+  type CofhesdkInputConfig,
+  getSupportedChainOrThrow,
+  getCoFheUrlOrThrow,
+  getZkVerifierUrlOrThrow,
+  getThresholdNetworkUrlOrThrow,
+} from './config.js';
+
+describe('createCofhesdkConfigBase', () => {
+  const validBaseConfig: CofhesdkInputConfig = {
+    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 {
+        createCofhesdkConfigBase(config as CofhesdkInputConfig);
+      } catch (e) {
+        console.log('expect config invalid', path, value, config, e);
+      }
+    }
+    expect(() => createCofhesdkConfigBase(config as CofhesdkInputConfig)).toThrow('Invalid cofhesdk configuration:');
+  };
+
+  const expectValidConfigItem = (path: string, value: any, expectedValue: any): void => {
+    const config = { ...validBaseConfig };
+    setNestedValue(config, path, value);
+    const result = createCofhesdkConfigBase(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('permitGeneration', () => {
+    expectInvalidConfigItem('permitGeneration', 'not-a-boolean');
+    expectInvalidConfigItem('permitGeneration', null);
+
+    expectValidConfigItem('permitGeneration', 'ON_CONNECT', 'ON_CONNECT');
+    expectValidConfigItem('permitGeneration', 'ON_DECRYPT_HANDLES', 'ON_DECRYPT_HANDLES');
+    expectValidConfigItem('permitGeneration', 'MANUAL', 'MANUAL');
+    expectValidConfigItem('permitGeneration', undefined, 'ON_CONNECT');
+  });
+
+  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 = createCofhesdkConfigBase(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);
+  });
+
+  it('mocks', () => {
+    expectInvalidConfigItem('mocks', 'not-an-object');
+    expectInvalidConfigItem('mocks', null);
+
+    expectValidConfigItem('mocks', { sealOutputDelay: 1000 }, { sealOutputDelay: 1000 });
+    expectValidConfigItem('mocks', undefined, { sealOutputDelay: 0 });
+  });
+
+  it('mocks.sealOutputDelay', () => {
+    expectInvalidConfigItem('mocks.sealOutputDelay', 'not-a-number');
+    expectInvalidConfigItem('mocks.sealOutputDelay', null);
+
+    expectValidConfigItem('mocks.sealOutputDelay', undefined, 0);
+    expectValidConfigItem('mocks.sealOutputDelay', 1000, 1000);
+  });
+
+  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: CofhesdkInputConfig = {
+      supportedChains: [sepolia],
+    };
+
+    const result = createCofhesdkConfigBase(config);
+
+    const supportedChains = getCofhesdkConfigItem(result, 'supportedChains');
+    expect(supportedChains).toEqual(config.supportedChains);
+  });
+});
+
+describe('Config helper functions', () => {
+  const config = createCofhesdkConfigBase({
+    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 = createCofhesdkConfigBase({
+        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 = createCofhesdkConfigBase({
+        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 = createCofhesdkConfigBase({
+        supportedChains: [{ ...sepolia, thresholdNetworkUrl: undefined } as any],
+      });
+      expect(() => getThresholdNetworkUrlOrThrow(configWithoutUrl, sepolia.id)).toThrow();
+    });
+  });
+});