@cofhe/sdk 0.4.0 → 0.5.1

package/permits/validation.ts

@@ -273,9 +273,9 @@ export const ValidationUtils = {
   },
 
   /**
-   * Overall validity checker of a permit
+   * Checks that a permit is signed and not expired.
    */
-  isValid: (permit: Permit): ValidationResult => {
+  isSignedAndNotExpired: (permit: Permit): ValidationResult => {
     if (ValidationUtils.isExpired(permit)) {
       return { valid: false, error: 'expired' };
     }
@@ -284,4 +284,44 @@ export const ValidationUtils = {
     }
     return { valid: true, error: null };
   },
+
+  /**
+   * Asserts that a permit is signed and not expired.
+   *
+   * Throws `Error` with message:
+   * - `Permit is expired`
+   * - `Permit is not signed`
+   */
+  assertSignedAndNotExpired: (permit: Permit): void => {
+    const result = ValidationUtils.isSignedAndNotExpired(permit);
+    if (result.valid) return;
+
+    if (result.error === 'expired') {
+      throw new Error('Permit is expired');
+    }
+    if (result.error === 'not-signed') {
+      throw new Error('Permit is not signed');
+    }
+
+    // Should be unreachable, but keeps this future-proof.
+    throw new Error('Permit is invalid');
+  },
+
+  isValid: (permit: Permit): ValidationResult => {
+    const schema =
+      permit.type === 'self'
+        ? SelfPermitValidator
+        : permit.type === 'sharing'
+          ? SharingPermitValidator
+          : permit.type === 'recipient'
+            ? ImportPermitValidator
+            : null;
+
+    if (schema == null) return { valid: false, error: 'invalid-schema' };
+
+    const schemaResult = schema.safeParse(permit);
+    if (!schemaResult.success) return { valid: false, error: 'invalid-schema' };
+
+    return ValidationUtils.isSignedAndNotExpired(permit);
+  },
 };

package/web/const.ts

@@ -0,0 +1,2 @@
+export const hasDOM =
+  typeof (globalThis as any)?.document !== 'undefined' && typeof (globalThis as any)?.window !== 'undefined';

package/web/index.ts

@@ -10,31 +10,45 @@ import {
   type FheKeyDeserializer,
   type EncryptableItem,
   fheTypeToString,
+  TFHE_RS_SAFE_SERIALIZATION_SIZE_LIMIT,
 } from '@/core';
 
 // Import web-specific storage (internal use only)
-import { createWebStorage } from './storage.js';
+import { createSsrStorage, createWebStorage } from './storage.js';
 
 // Import worker manager
 import { getWorkerManager, terminateWorker, areWorkersAvailable } from './workerManager.js';
 
-// Import tfhe for web
-import init, { init_panic_hook, TfheCompactPublicKey, ProvenCompactCiphertextList, CompactPkeCrs } from 'tfhe';
+// Type-only import for tfhe — the runtime is loaded lazily via `await import('tfhe')`
+// inside `initTfhe()` so that simply importing `@cofhe/sdk/web` (e.g. transitively
+// through `@cofhe/react`) does not pull tfhe — and its worker helpers that
+// reference `self` at module top — into the import graph during Next.js SSR.
+import type { TfheCompactPublicKey, ProvenCompactCiphertextList, CompactPkeCrs } from 'tfhe';
+import { hasDOM } from './const';
 
 /**
  * Internal function to initialize TFHE for web
  * Called automatically on first encryption - users don't need to call this manually
  * @returns true if TFHE was initialized, false if already initialized
  */
+let tfheModule: typeof import('tfhe') | null = null;
 let tfheInitialized = false;
 async function initTfhe(): Promise<boolean> {
   if (tfheInitialized) return false;
-  await init();
-  await init_panic_hook();
+  tfheModule = await import('tfhe');
+  await tfheModule.default();
+  await tfheModule.init_panic_hook();
   tfheInitialized = true;
   return true;
 }
 
+function requireTfhe(): typeof import('tfhe') {
+  if (!tfheModule) {
+    throw new Error('TFHE not initialized — call initTfhe() (or any client method that triggers it) first');
+  }
+  return tfheModule;
+}
+
 /**
  * Utility to convert the hex string key to a Uint8Array for use with tfhe
  */
@@ -45,12 +59,23 @@ const fromHexString = (hexString: string): Uint8Array => {
   return new Uint8Array(arr.map((byte) => parseInt(byte, 16)));
 };
 
+const _deserializeTfhePublicKey = (buff: string): TfheCompactPublicKey => {
+  return requireTfhe().TfheCompactPublicKey.safe_deserialize(
+    fromHexString(buff),
+    TFHE_RS_SAFE_SERIALIZATION_SIZE_LIMIT
+  );
+};
+
+const _deserializeCompactPkeCrs = (buff: string): CompactPkeCrs => {
+  return requireTfhe().CompactPkeCrs.safe_deserialize(fromHexString(buff), TFHE_RS_SAFE_SERIALIZATION_SIZE_LIMIT);
+};
+
 /**
  * Serializer for TFHE public keys
  * Validates that the buffer can be deserialized into a TfheCompactPublicKey
  */
 const tfhePublicKeyDeserializer: FheKeyDeserializer = (buff: string): void => {
-  TfheCompactPublicKey.deserialize(fromHexString(buff));
+  _deserializeTfhePublicKey(buff);
 };
 
 /**
@@ -58,7 +83,7 @@ const tfhePublicKeyDeserializer: FheKeyDeserializer = (buff: string): void => {
  * Validates that the buffer can be deserialized into ZkCompactPkePublicParams
  */
 const compactPkeCrsDeserializer: FheKeyDeserializer = (buff: string): void => {
-  CompactPkeCrs.deserialize(fromHexString(buff));
+  _deserializeCompactPkeCrs(buff);
 };
 
 /**
@@ -66,9 +91,9 @@ const compactPkeCrsDeserializer: FheKeyDeserializer = (buff: string): void => {
  * This is used internally by the SDK to create encrypted inputs
  */
 const zkBuilderAndCrsGenerator: ZkBuilderAndCrsGenerator = (fhe: string, crs: string) => {
-  const fhePublicKey = TfheCompactPublicKey.deserialize(fromHexString(fhe));
-  const zkBuilder = ProvenCompactCiphertextList.builder(fhePublicKey);
-  const zkCrs = CompactPkeCrs.deserialize(fromHexString(crs));
+  const fhePublicKey = _deserializeTfhePublicKey(fhe);
+  const zkBuilder = requireTfhe().ProvenCompactCiphertextList.builder(fhePublicKey);
+  const zkCrs = _deserializeCompactPkeCrs(crs);
 
   return { zkBuilder, zkCrs };
 };
@@ -103,7 +128,8 @@ export function createCofheConfig(config: CofheInputConfig): CofheConfig {
   return createCofheConfigBase({
     environment: 'web',
     ...config,
-    fheKeyStorage: config.fheKeyStorage === null ? null : config.fheKeyStorage ?? createWebStorage(),
+    fheKeyStorage:
+      config.fheKeyStorage === null ? null : config.fheKeyStorage ?? (hasDOM ? createWebStorage() : createSsrStorage()),
   });
 }
 
@@ -159,3 +185,6 @@ export function createCofheClientWithCustomWorker(
     zkProveWorkerFn: customZkProveWorkerFn,
   });
 }
+
+export { createSsrStorage };
+export { hasDOM } from './const';

package/web/storage.ts

@@ -1,15 +1,19 @@
 import type { IStorage } from '@/core';
 import { constructClient } from 'iframe-shared-storage';
+import { hasDOM } from './const';
 /**
- * Creates a web storage implementation using IndexedDB
+ * Creates a web storage implementation using IndexedDB.
+ * Must only be called in a browser environment (requires `document` for iframe injection).
  * @returns IStorage implementation for browser environments
  */
-export const createWebStorage = (): IStorage => {
+export const createWebStorage = (opts = { enableLog: false }): IStorage => {
+  if (!hasDOM) throw new Error('createWebStorage can only be used in a browser environment');
+
   const client = constructClient({
     iframe: {
       src: 'https://iframe-shared-storage.vercel.app/hub.html',
       messagingOptions: {
-        enableLog: 'both',
+        enableLog: opts.enableLog ? 'both' : undefined,
       },
 
       iframeReadyTimeoutMs: 30_000, // if the iframe is not initied during this interval AND a reuqest is made, such request will throw an error
@@ -32,3 +36,14 @@ export const createWebStorage = (): IStorage => {
     },
   };
 };
+
+export function createSsrStorage(): IStorage {
+  // TODO: consider doing something like wagmi's cookies storage for SSR - this in-memory storage will not persist across requests, but it also won't throw errors if accessed in SSR (e.g. during getServerSideProps in Next.js)
+  // https://wagmi.sh/react/guides/ssr#_1-set-up-cookie-storage
+  console.warn('using no-op server-side SSR storage');
+  return {
+    getItem: async () => null,
+    setItem: async () => {},
+    removeItem: async () => {},
+  };
+}

package/web/{client.web.test.ts → test/client.web.test.ts}

@@ -6,7 +6,7 @@ import { arbitrumSepolia as viemArbitrumSepolia } from 'viem/chains';
 import type { PublicClient, WalletClient } from 'viem';
 import { createPublicClient, createWalletClient, http } from 'viem';
 import { privateKeyToAccount } from 'viem/accounts';
-import { createCofheClient, createCofheConfig } from './index.js';
+import { createCofheClient, createCofheConfig } from '../index.js';
 
 // Real test setup - runs in browser
 const TEST_PRIVATE_KEY = '0xac0974bec39a17e36ba4a6b4d238ff944bacb478cbed5efcae784d7bf4f2ff80';
@@ -141,7 +141,19 @@ describe('@cofhe/web - Client', () => {
       expect(builder).toBeDefined();
       expect(typeof builder.setChainId).toBe('function');
       expect(typeof builder.setAccount).toBe('function');
+      expect(typeof builder.onPoll).toBe('function');
       expect(typeof builder.execute).toBe('function');
     }, 30000);
+
+    it('should create decryptForTx builder after connection', async () => {
+      await cofheClient.connect(publicClient, walletClient);
+
+      const builder = cofheClient.decryptForTx('0x123');
+
+      expect(builder).toBeDefined();
+      expect(typeof builder.setChainId).toBe('function');
+      expect(typeof builder.setAccount).toBe('function');
+      expect(typeof builder.onPoll).toBe('function');
+    }, 30000);
   });
 });

package/web/test/config.web.test.ts

@@ -0,0 +1,16 @@
+import { arbSepolia } from '@/chains';
+
+import { describe, it, expect } from 'vitest';
+import { createCofheConfig } from '../index.js';
+
+describe('@cofhe/web - Config', () => {
+  it('should automatically inject IndexedDB storage as default', () => {
+    const config = createCofheConfig({
+      supportedChains: [arbSepolia],
+    });
+
+    expect(config.fheKeyStorage).toBeDefined();
+    expect(config.fheKeyStorage).not.toBeNull();
+    expect(config.supportedChains).toEqual([arbSepolia]);
+  });
+});

package/web/test/inherited.web.test.ts

@@ -0,0 +1,245 @@
+import { Encryptable, FheTypes, type CofheClient } from '@/core';
+import { arbSepolia as cofheArbSepolia, getChainById } from '@/chains';
+import {
+  TEST_PRIVATE_KEY,
+  PRIMARY_TEST_CHAIN,
+  primaryTestChainRegistry,
+  isPrimaryTestChainReady,
+} from '@cofhe/test-setup';
+
+import { createCofheClient, createCofheConfig } from '../index.js';
+
+import { describe, it, expect, beforeAll, beforeEach } from 'vitest';
+import type { Chain, PublicClient, WalletClient } from 'viem';
+import { createPublicClient, createWalletClient, http } from 'viem';
+import { privateKeyToAccount } from 'viem/accounts';
+import { arbitrumSepolia, baseSepolia, sepolia } from 'viem/chains';
+
+const DEFAULT_TEST_PRIVATE_KEY = '0xac0974bec39a17e36ba4a6b4d238ff944bacb478cbed5efcae784d7bf4f2ff80';
+const BOB_PRIVATE_KEY = (TEST_PRIVATE_KEY || DEFAULT_TEST_PRIVATE_KEY) as `0x${string}`;
+const ALICE_PRIVATE_KEY = '0x59c6995e998f97a5a0044966f0945389dc9e86dae88c7a8412f4603b6b78690d';
+
+const bobAccount = privateKeyToAccount(BOB_PRIVATE_KEY);
+const aliceAccount = privateKeyToAccount(ALICE_PRIVATE_KEY);
+
+const VIEM_CHAINS: Record<number, Chain> = {
+  421614: arbitrumSepolia,
+  84532: baseSepolia,
+  11155111: sepolia,
+};
+
+describe('@cofhe/web - Inherited Client Tests', () => {
+  let cofheClient: CofheClient;
+  let publicClient: PublicClient;
+  let bobWalletClient: WalletClient;
+  let aliceWalletClient: WalletClient;
+
+  beforeAll(() => {
+    publicClient = createPublicClient({
+      chain: arbitrumSepolia,
+      transport: http(),
+    });
+
+    bobWalletClient = createWalletClient({
+      chain: arbitrumSepolia,
+      transport: http(),
+      account: bobAccount,
+    });
+
+    aliceWalletClient = createWalletClient({
+      chain: arbitrumSepolia,
+      transport: http(),
+      account: aliceAccount,
+    });
+  });
+
+  beforeEach(() => {
+    const config = createCofheConfig({
+      supportedChains: [cofheArbSepolia],
+    });
+    cofheClient = createCofheClient(config);
+  });
+
+  describe('Client Creation', () => {
+    it('should create a client with expected surface', () => {
+      expect(cofheClient).toBeDefined();
+      expect(cofheClient.config).toBeDefined();
+      expect(cofheClient.connected).toBe(false);
+      expect(typeof cofheClient.connect).toBe('function');
+      expect(typeof cofheClient.disconnect).toBe('function');
+      expect(typeof cofheClient.encryptInputs).toBe('function');
+      expect(typeof cofheClient.decryptForView).toBe('function');
+      expect(typeof cofheClient.decryptForTx).toBe('function');
+      expect(typeof cofheClient.getSnapshot).toBe('function');
+      expect(typeof cofheClient.subscribe).toBe('function');
+      expect(cofheClient.permits).toBeDefined();
+    });
+  });
+
+  describe('Connection', () => {
+    it('should connect to a real chain', async () => {
+      await cofheClient.connect(publicClient, bobWalletClient);
+
+      expect(cofheClient.connected).toBe(true);
+
+      const snapshot = cofheClient.getSnapshot();
+      expect(snapshot.connected).toBe(true);
+      expect(snapshot.chainId).toBe(cofheArbSepolia.id);
+      expect(snapshot.account).toBe(bobAccount.address);
+    }, 30000);
+  });
+
+  describe('Encrypt Input', () => {
+    it('should encrypt a uint128 value', async () => {
+      await cofheClient.connect(publicClient, bobWalletClient);
+
+      const encrypted = await cofheClient.encryptInputs([Encryptable.uint128(100n)]).execute();
+
+      expect(encrypted).toBeDefined();
+      expect(encrypted.length).toBe(1);
+      expect(encrypted[0].utype).toBe(FheTypes.Uint128);
+      expect(encrypted[0].ctHash).toBeDefined();
+      expect(typeof encrypted[0].ctHash).toBe('bigint');
+      expect(encrypted[0].signature).toBeDefined();
+      expect(typeof encrypted[0].signature).toBe('string');
+      expect(encrypted[0].securityZone).toBe(0);
+    }, 60000);
+  });
+
+  describe('Self Permit', () => {
+    it('should create a self permit', async () => {
+      await cofheClient.connect(publicClient, bobWalletClient);
+
+      const permit = await cofheClient.permits.createSelf({
+        issuer: bobAccount.address,
+        name: 'Test Self Permit',
+      });
+
+      expect(permit).toBeDefined();
+      expect(permit.type).toBe('self');
+      expect(permit.name).toBe('Test Self Permit');
+      expect(permit.issuer).toBe(bobAccount.address);
+      expect(permit.issuerSignature).not.toBe('0x');
+      expect(permit.sealingPair).toBeDefined();
+      expect(permit.sealingPair.publicKey).toBeDefined();
+
+      const activePermit = cofheClient.permits.getActivePermit();
+      expect(activePermit).toBeDefined();
+      expect(activePermit!.hash).toBe(permit.hash);
+    }, 30000);
+  });
+
+  describe('Sharing Permit', () => {
+    it('should create a sharing permit, export it, and import it as another user', async () => {
+      await cofheClient.connect(publicClient, bobWalletClient);
+
+      const sharingPermit = await cofheClient.permits.createSharing({
+        issuer: bobAccount.address,
+        recipient: aliceAccount.address,
+        name: 'Test Sharing Permit',
+      });
+
+      expect(sharingPermit).toBeDefined();
+      expect(sharingPermit.type).toBe('sharing');
+      expect(sharingPermit.issuer).toBe(bobAccount.address);
+      expect(sharingPermit.recipient).toBe(aliceAccount.address);
+      expect(sharingPermit.issuerSignature).not.toBe('0x');
+
+      const exported = cofheClient.permits.export(sharingPermit);
+      expect(exported).toBeDefined();
+      const parsed = JSON.parse(exported);
+      expect(parsed.type).toBe('sharing');
+      expect(parsed.issuer).toBe(bobAccount.address);
+      expect(parsed.recipient).toBe(aliceAccount.address);
+      expect(parsed.issuerSignature).toBeDefined();
+      expect(parsed).not.toHaveProperty('sealingPair');
+
+      const aliceConfig = createCofheConfig({
+        supportedChains: [cofheArbSepolia],
+      });
+      const aliceClient = createCofheClient(aliceConfig);
+      await aliceClient.connect(publicClient, aliceWalletClient);
+
+      const importedPermit = await aliceClient.permits.importShared(exported);
+
+      expect(importedPermit).toBeDefined();
+      expect(importedPermit.type).toBe('recipient');
+      expect(importedPermit.issuer).toBe(bobAccount.address);
+      expect(importedPermit.recipient).toBe(aliceAccount.address);
+      expect(importedPermit.recipientSignature).not.toBe('0x');
+      expect(importedPermit.sealingPair).toBeDefined();
+    }, 30000);
+  });
+
+  describe('Decrypt (read-only, pre-stored values)', () => {
+    let decryptClient: CofheClient;
+    let decryptPublicClient: PublicClient;
+    let decryptWalletClient: WalletClient;
+
+    let privateCtHash: `0x${string}`;
+    let privateValue: bigint;
+    let publicCtHash: `0x${string}`;
+    let publicValue: bigint;
+
+    beforeAll(() => {
+      if (!isPrimaryTestChainReady(primaryTestChainRegistry)) {
+        throw new Error('Primary test chain registry not initialized. Run `pnpm test:setup` first.');
+      }
+
+      const reg = primaryTestChainRegistry;
+      const viemChain = VIEM_CHAINS[reg.chainId];
+      if (!viemChain) throw new Error(`No viem chain mapping for chain ${reg.chainId}`);
+
+      const cofheChain = getChainById(reg.chainId);
+      if (!cofheChain) throw new Error(`No cofhe chain config for chain ${reg.chainId}`);
+
+      privateCtHash = reg.privateValue.ctHash as `0x${string}`;
+      privateValue = BigInt(reg.privateValue.value);
+      publicCtHash = reg.publicValue.ctHash as `0x${string}`;
+      publicValue = BigInt(reg.publicValue.value);
+
+      decryptPublicClient = createPublicClient({ chain: viemChain, transport: http() });
+      decryptWalletClient = createWalletClient({ chain: viemChain, transport: http(), account: bobAccount });
+
+      const config = createCofheConfig({ supportedChains: [cofheChain] });
+      decryptClient = createCofheClient(config);
+    });
+
+    it('decryptForView — private value with permit', async () => {
+      await decryptClient.connect(decryptPublicClient, decryptWalletClient);
+
+      await decryptClient.permits.createSelf({
+        issuer: bobAccount.address,
+        name: 'Decrypt View Permit',
+      });
+
+      const result = await decryptClient.decryptForView(privateCtHash, FheTypes.Uint32).execute();
+      expect(result).toBe(privateValue);
+    }, 180000);
+
+    it('decryptForTx — public value without permit', async () => {
+      await decryptClient.connect(decryptPublicClient, decryptWalletClient);
+
+      const result = await decryptClient.decryptForTx(publicCtHash).withoutPermit().execute();
+
+      expect(BigInt(result.ctHash)).toBe(BigInt(publicCtHash));
+      expect(result.decryptedValue).toBe(publicValue);
+      expect(result.signature).toMatch(/^0x[0-9a-fA-F]+$/);
+    }, 180000);
+
+    it('decryptForTx — private value with permit', async () => {
+      await decryptClient.connect(decryptPublicClient, decryptWalletClient);
+
+      const permit = await decryptClient.permits.createSelf({
+        issuer: bobAccount.address,
+        name: 'Decrypt Tx Permit',
+      });
+
+      const result = await decryptClient.decryptForTx(privateCtHash).withPermit(permit).execute();
+
+      expect(BigInt(result.ctHash)).toBe(BigInt(privateCtHash));
+      expect(result.decryptedValue).toBe(privateValue);
+      expect(result.signature).toBeDefined();
+    }, 180000);
+  });
+});

package/web/test/tfheinit.web.test.ts

@@ -0,0 +1,62 @@
+import { arbSepolia as cofheArbSepolia } from '@/chains';
+import { Encryptable, FheTypes, type CofheClient, CofheErrorCode, CofheError } from '@/core';
+
+import { describe, it, expect, beforeAll, beforeEach } from 'vitest';
+import type { PublicClient, WalletClient } from 'viem';
+import { createPublicClient, createWalletClient, http } from 'viem';
+import { privateKeyToAccount } from 'viem/accounts';
+import { arbitrumSepolia as viemArbitrumSepolia } from 'viem/chains';
+import { createCofheClient, createCofheConfig } from '../index.js';
+
+// Real test setup - runs in browser with real tfhe
+const TEST_PRIVATE_KEY = '0xac0974bec39a17e36ba4a6b4d238ff944bacb478cbed5efcae784d7bf4f2ff80';
+
+describe('@cofhe/web - TFHE Initialization Browser Tests', () => {
+  let cofheClient: CofheClient;
+  let publicClient: PublicClient;
+  let walletClient: WalletClient;
+
+  beforeAll(() => {
+    // Create real viem clients
+    publicClient = createPublicClient({
+      chain: viemArbitrumSepolia,
+      transport: http(),
+    });
+
+    const account = privateKeyToAccount(TEST_PRIVATE_KEY);
+    walletClient = createWalletClient({
+      chain: viemArbitrumSepolia,
+      transport: http(),
+      account,
+    });
+  });
+
+  beforeEach(() => {
+    const config = createCofheConfig({
+      supportedChains: [cofheArbSepolia],
+    });
+    cofheClient = createCofheClient(config);
+  });
+
+  describe('Browser TFHE Initialization', () => {
+    it('should initialize tfhe on first encryption', async () => {
+      await cofheClient.connect(publicClient, walletClient);
+
+      // This will trigger real TFHE initialization in browser
+      const result = await cofheClient.encryptInputs([Encryptable.uint128(100n)]).execute();
+
+      // If we get here, TFHE was initialized successfully
+      expect(result).toBeDefined();
+    }, 60000); // Longer timeout for real operations
+
+    it('should handle multiple encryptions without re-initializing', async () => {
+      await cofheClient.connect(publicClient, walletClient);
+
+      // First encryption
+      expect(cofheClient.encryptInputs([Encryptable.uint128(100n)]).execute()).resolves.not.toThrow();
+
+      // Second encryption should reuse initialization
+      expect(cofheClient.encryptInputs([Encryptable.uint64(50n)]).execute()).resolves.not.toThrow();
+    }, 60000);
+  });
+});

package/web/{worker.config.web.test.ts → test/worker.config.web.test.ts}

@@ -6,7 +6,7 @@ import type { PublicClient, WalletClient } from 'viem';
 import { createPublicClient, createWalletClient, http } from 'viem';
 import { privateKeyToAccount } from 'viem/accounts';
 import { arbitrumSepolia as viemArbitrumSepolia } from 'viem/chains';
-import { createCofheClient, createCofheConfig, createCofheClientWithCustomWorker } from './index.js';
+import { createCofheClient, createCofheConfig, createCofheClientWithCustomWorker } from '../index.js';
 
 const TEST_PRIVATE_KEY = '0xac0974bec39a17e36ba4a6b4d238ff944bacb478cbed5efcae784d7bf4f2ff80';
 

package/web/{worker.output.web.test.ts → test/worker.output.web.test.ts}

@@ -6,7 +6,7 @@ import type { PublicClient, WalletClient } from 'viem';
 import { createPublicClient, createWalletClient, http } from 'viem';
 import { privateKeyToAccount } from 'viem/accounts';
 import { arbitrumSepolia as viemArbitrumSepolia } from 'viem/chains';
-import { createCofheClient, createCofheConfig } from './index.js';
+import { createCofheClient, createCofheConfig } from '../index.js';
 
 const TEST_PRIVATE_KEY = '0xac0974bec39a17e36ba4a6b4d238ff944bacb478cbed5efcae784d7bf4f2ff80';
 

package/web/{workerManager.test.ts → test/workerManager.test.ts}

@@ -1,5 +1,5 @@
 import { describe, it, expect, afterEach } from 'vitest';
-import { getWorkerManager, terminateWorker, areWorkersAvailable } from './workerManager.js';
+import { getWorkerManager, terminateWorker, areWorkersAvailable } from '../workerManager.js';
 
 describe('WorkerManager', () => {
   afterEach(() => {

package/web/{workerManager.web.test.ts → test/workerManager.web.test.ts}

@@ -1,5 +1,5 @@
 import { describe, it, expect, afterEach } from 'vitest';
-import { getWorkerManager, terminateWorker, areWorkersAvailable } from './workerManager.js';
+import { getWorkerManager, terminateWorker, areWorkersAvailable } from '../workerManager.js';
 
 describe('WorkerManager (Browser)', () => {
   afterEach(() => {