@cofhe/sdk 0.0.0-beta-20251027110729

package/dist/web.d.cts

@@ -0,0 +1,22 @@
+import { d as CofhesdkInputConfig, b as CofhesdkConfig, a as CofhesdkClient } from './types-bB7wLj0q.cjs';
+import './permit-S9CnI6MF.cjs';
+import 'zod';
+import 'viem';
+import './types-KImPrEIe.cjs';
+import 'zustand/vanilla';
+
+/**
+ * Creates a CoFHE SDK configuration for web with IndexedDB storage as default
+ * @param config - The CoFHE SDK input configuration (fheKeyStorage will default to IndexedDB if not provided)
+ * @returns The CoFHE SDK configuration with web defaults applied
+ */
+declare function createCofhesdkConfig(config: CofhesdkInputConfig): CofhesdkConfig;
+/**
+ * Creates a CoFHE SDK client instance for web with TFHE automatically configured
+ * TFHE will be initialized automatically on first encryption - no manual setup required
+ * @param config - The CoFHE SDK configuration (use createCofhesdkConfig to create with web defaults)
+ * @returns The CoFHE SDK client instance
+ */
+declare function createCofhesdkClient(config: CofhesdkConfig): CofhesdkClient;
+
+export { createCofhesdkClient, createCofhesdkConfig };

package/dist/web.d.ts

@@ -0,0 +1,22 @@
+import { d as CofhesdkInputConfig, b as CofhesdkConfig, a as CofhesdkClient } from './types-PhwGgQvs.js';
+import './permit-S9CnI6MF.js';
+import 'zod';
+import 'viem';
+import './types-KImPrEIe.js';
+import 'zustand/vanilla';
+
+/**
+ * Creates a CoFHE SDK configuration for web with IndexedDB storage as default
+ * @param config - The CoFHE SDK input configuration (fheKeyStorage will default to IndexedDB if not provided)
+ * @returns The CoFHE SDK configuration with web defaults applied
+ */
+declare function createCofhesdkConfig(config: CofhesdkInputConfig): CofhesdkConfig;
+/**
+ * Creates a CoFHE SDK client instance for web with TFHE automatically configured
+ * TFHE will be initialized automatically on first encryption - no manual setup required
+ * @param config - The CoFHE SDK configuration (use createCofhesdkConfig to create with web defaults)
+ * @returns The CoFHE SDK client instance
+ */
+declare function createCofhesdkClient(config: CofhesdkConfig): CofhesdkClient;
+
+export { createCofhesdkClient, createCofhesdkConfig };

package/dist/web.js

@@ -0,0 +1,64 @@
+import { createCofhesdkConfigBase, createCofhesdkClientBase } from './chunk-KFGPTJ6X.js';
+import './chunk-GZCQQYVI.js';
+import './chunk-LU7BMUUT.js';
+import { get, set, del } from 'idb-keyval';
+import init, { init_panic_hook, TfheCompactPublicKey, CompactPkeCrs, ProvenCompactCiphertextList } from 'tfhe';
+
+var createWebStorage = () => {
+  return {
+    getItem: async (name) => {
+      return await get(name) || null;
+    },
+    setItem: async (name, value) => {
+      await set(name, value);
+    },
+    removeItem: async (name) => {
+      await del(name);
+    }
+  };
+};
+var tfheInitialized = false;
+async function initTfhe() {
+  if (tfheInitialized)
+    return false;
+  await init();
+  await init_panic_hook();
+  tfheInitialized = true;
+  return true;
+}
+var fromHexString = (hexString) => {
+  const cleanString = hexString.length % 2 === 1 ? `0${hexString}` : hexString;
+  const arr = cleanString.replace(/^0x/, "").match(/.{1,2}/g);
+  if (!arr)
+    return new Uint8Array();
+  return new Uint8Array(arr.map((byte) => parseInt(byte, 16)));
+};
+var tfhePublicKeyDeserializer = (buff) => {
+  TfheCompactPublicKey.deserialize(fromHexString(buff));
+};
+var compactPkeCrsDeserializer = (buff) => {
+  CompactPkeCrs.deserialize(fromHexString(buff));
+};
+var zkBuilderAndCrsGenerator = (fhe, crs) => {
+  const fhePublicKey = TfheCompactPublicKey.deserialize(fromHexString(fhe));
+  const zkBuilder = ProvenCompactCiphertextList.builder(fhePublicKey);
+  const zkCrs = CompactPkeCrs.deserialize(fromHexString(crs));
+  return { zkBuilder, zkCrs };
+};
+function createCofhesdkConfig(config) {
+  return createCofhesdkConfigBase({
+    ...config,
+    fheKeyStorage: config.fheKeyStorage === null ? null : config.fheKeyStorage ?? createWebStorage()
+  });
+}
+function createCofhesdkClient(config) {
+  return createCofhesdkClientBase({
+    config,
+    zkBuilderAndCrsGenerator,
+    tfhePublicKeyDeserializer,
+    compactPkeCrsDeserializer,
+    initTfhe
+  });
+}
+
+export { createCofhesdkClient, createCofhesdkConfig };

package/node/client.test.ts

@@ -0,0 +1,152 @@
+import { type CofhesdkClient } from '@/core';
+import { arbSepolia as cofhesdkArbSepolia } from '@/chains';
+
+import { describe, it, expect, beforeAll, beforeEach, vi } 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 { createCofhesdkClient, createCofhesdkConfig } from './index.js';
+
+// Real test setup - no mocks
+const TEST_PRIVATE_KEY = '0xac0974bec39a17e36ba4a6b4d238ff944bacb478cbed5efcae784d7bf4f2ff80';
+const TEST_ACCOUNT = privateKeyToAccount(TEST_PRIVATE_KEY).address;
+
+describe('@cofhe/node - Client Integration Tests', () => {
+  let cofhesdkClient: CofhesdkClient;
+  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 = createCofhesdkConfig({
+      supportedChains: [cofhesdkArbSepolia],
+    });
+    cofhesdkClient = createCofhesdkClient(config);
+  });
+
+  describe('Real Client Initialization', () => {
+    it('should create a client with real node-tfhe', () => {
+      expect(cofhesdkClient).toBeDefined();
+      expect(cofhesdkClient.config).toBeDefined();
+      expect(cofhesdkClient.connected).toBe(false);
+    });
+
+    it('should automatically use filesystem storage as default', () => {
+      expect(cofhesdkClient.config.fheKeyStorage).toBeDefined();
+      expect(cofhesdkClient.config.fheKeyStorage).not.toBeNull();
+    });
+
+    it('should have all expected methods', () => {
+      expect(typeof cofhesdkClient.connect).toBe('function');
+      expect(typeof cofhesdkClient.encryptInputs).toBe('function');
+      expect(typeof cofhesdkClient.decryptHandle).toBe('function');
+      expect(typeof cofhesdkClient.getSnapshot).toBe('function');
+      expect(typeof cofhesdkClient.subscribe).toBe('function');
+    });
+  });
+
+  describe('Real Connection', () => {
+    it('should connect to real chain', async () => {
+      const result = await cofhesdkClient.connect(publicClient, walletClient);
+
+      expect(result.success).toBe(true);
+      expect(cofhesdkClient.connected).toBe(true);
+
+      const snapshot = cofhesdkClient.getSnapshot();
+      expect(snapshot.connected).toBe(true);
+      expect(snapshot.chainId).toBe(cofhesdkArbSepolia.id);
+      expect(snapshot.account).toBe(TEST_ACCOUNT);
+    }, 30000);
+
+    it('should handle real network errors', async () => {
+      const result = await cofhesdkClient.connect(
+        {
+          getChainId: vi.fn().mockRejectedValue(new Error('Network error')),
+        } as unknown as PublicClient,
+        walletClient
+      );
+
+      expect(result.success).toBe(false);
+      expect(cofhesdkClient.connected).toBe(false);
+    }, 30000);
+  });
+
+  describe('State Management', () => {
+    it('should track connection state changes', async () => {
+      const states: any[] = [];
+      const unsubscribe = cofhesdkClient.subscribe((snapshot) => {
+        states.push({ ...snapshot });
+      });
+
+      await cofhesdkClient.connect(publicClient, walletClient);
+
+      unsubscribe();
+
+      expect(states.length).toBeGreaterThan(0);
+
+      // First state should be connecting
+      const firstState = states.find((s) => s.connecting);
+      expect(firstState).toBeDefined();
+      expect(firstState?.connecting).toBe(true);
+      expect(firstState?.connected).toBe(false);
+
+      // Last state should be connected
+      const lastState = states[states.length - 1];
+      expect(lastState.connected).toBe(true);
+      expect(lastState.connecting).toBe(false);
+      expect(lastState.chainId).toBe(cofhesdkArbSepolia.id);
+    }, 30000);
+  });
+
+  describe('Initialization Results', () => {
+    it('should have keyFetchResult promise', () => {
+      expect(cofhesdkClient.initializationResults).toBeDefined();
+      expect(cofhesdkClient.initializationResults.keyFetchResult).toBeInstanceOf(Promise);
+    });
+
+    it('should resolve keyFetchResult', async () => {
+      const result = await cofhesdkClient.initializationResults.keyFetchResult;
+      expect(result.success).toBe(true);
+    });
+  });
+
+  describe('Builder Creation', () => {
+    it('should create encrypt builder after connection', async () => {
+      await cofhesdkClient.connect(publicClient, walletClient);
+
+      const builder = cofhesdkClient.encryptInputs([{ data: 100n, utype: 2 }]);
+
+      expect(builder).toBeDefined();
+      expect(typeof builder.setChainId).toBe('function');
+      expect(typeof builder.setAccount).toBe('function');
+      expect(typeof builder.setSecurityZone).toBe('function');
+      expect(typeof builder.encrypt).toBe('function');
+    }, 30000);
+
+    it('should create decrypt builder after connection', async () => {
+      await cofhesdkClient.connect(publicClient, walletClient);
+
+      const builder = cofhesdkClient.decryptHandle(123n, 2);
+
+      expect(builder).toBeDefined();
+      expect(typeof builder.setChainId).toBe('function');
+      expect(typeof builder.setAccount).toBe('function');
+      expect(typeof builder.decrypt).toBe('function');
+    }, 30000);
+  });
+});

package/node/config.test.ts

@@ -0,0 +1,68 @@
+import { arbSepolia } from '@/chains';
+
+import { describe, it, expect } from 'vitest';
+import { createCofhesdkConfig, createCofhesdkClient } from './index.js';
+
+describe('@cofhe/node - Config', () => {
+  describe('createCofhesdkConfig', () => {
+    it('should automatically inject filesystem storage as default', () => {
+      const config = createCofhesdkConfig({
+        supportedChains: [arbSepolia],
+      });
+
+      expect(config.fheKeyStorage).toBeDefined();
+      expect(config.fheKeyStorage).not.toBeNull();
+      expect(config.supportedChains).toEqual([arbSepolia]);
+    });
+
+    it('should allow overriding storage', async () => {
+      const customStorage = {
+        getItem: () => Promise.resolve(10),
+        setItem: () => Promise.resolve(),
+        removeItem: () => Promise.resolve(),
+      };
+      const config = createCofhesdkConfig({
+        supportedChains: [arbSepolia],
+        fheKeyStorage: customStorage,
+      });
+
+      expect(await config.fheKeyStorage!.getItem('test')).toBe(10);
+    });
+
+    it('should allow null storage', () => {
+      const config = createCofhesdkConfig({
+        supportedChains: [arbSepolia],
+        fheKeyStorage: null,
+      });
+
+      expect(config.fheKeyStorage).toBeNull();
+    });
+
+    it('should preserve all other config options', () => {
+      const config = createCofhesdkConfig({
+        supportedChains: [arbSepolia],
+        mocks: {
+          sealOutputDelay: 0,
+        },
+      });
+
+      expect(config.supportedChains).toEqual([arbSepolia]);
+      expect(config.mocks.sealOutputDelay).toBe(0);
+      expect(config.fheKeyStorage).toBeDefined();
+    });
+  });
+
+  describe('createCofhesdkClient with config', () => {
+    it('should create client with validated config', () => {
+      const config = createCofhesdkConfig({
+        supportedChains: [arbSepolia],
+      });
+
+      const client = createCofhesdkClient(config);
+
+      expect(client).toBeDefined();
+      expect(client.config).toBe(config);
+      expect(client.config.fheKeyStorage).toBeDefined();
+    });
+  });
+});

package/node/encryptInputs.test.ts

@@ -0,0 +1,175 @@
+import { Encryptable, FheTypes, type CofhesdkClient, type Result, CofhesdkErrorCode, CofhesdkError } from '@/core';
+import { arbSepolia as cofhesdkArbSepolia } from '@/chains';
+
+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 { createCofhesdkClient, createCofhesdkConfig } from './index.js';
+
+// Real test setup - using actual node-tfhe
+const TEST_PRIVATE_KEY = '0xac0974bec39a17e36ba4a6b4d238ff944bacb478cbed5efcae784d7bf4f2ff80';
+
+const expectResultSuccess = <T>(result: Result<T>): T => {
+  expect(result.success, `Result error: ${result.error?.toString()}`).toBe(true);
+  return result.data!;
+};
+
+const expectResultError = <T>(result: Result<T>, errorCode?: CofhesdkErrorCode): void => {
+  expect(result.success).toBe(false);
+  expect(result.data).toBe(null);
+  expect(result.error).not.toBe(null);
+  const error = result.error as CofhesdkError;
+  expect(error).toBeInstanceOf(CofhesdkError);
+  if (errorCode) {
+    expect(error.code, `Result error: ${result.error?.toString()}`).toBe(errorCode);
+  }
+};
+
+describe('@cofhe/node - Encrypt Inputs', () => {
+  let cofhesdkClient: CofhesdkClient;
+  let publicClient: PublicClient;
+  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 = createCofhesdkConfig({
+      supportedChains: [cofhesdkArbSepolia],
+    });
+    cofhesdkClient = createCofhesdkClient(config);
+  });
+
+  describe('Real TFHE Initialization', () => {
+    it('should initialize node-tfhe on first encryption', async () => {
+      await cofhesdkClient.connect(publicClient, walletClient);
+
+      // This will trigger real TFHE initialization
+      const result = await cofhesdkClient.encryptInputs([Encryptable.uint128(100n)]).encrypt();
+      const encrypted = expectResultSuccess(result);
+
+      // If we get here, TFHE was initialized successfully
+      expect(encrypted).toBeDefined();
+    }, 60000); // Longer timeout for real operations
+
+    it('should handle multiple encryptions without re-initializing', async () => {
+      await cofhesdkClient.connect(publicClient, walletClient);
+
+      // First encryption
+      const result1 = await cofhesdkClient.encryptInputs([Encryptable.uint128(100n)]).encrypt();
+      expectResultSuccess(result1);
+
+      // Second encryption should reuse initialization
+      const result2 = await cofhesdkClient.encryptInputs([Encryptable.uint64(50n)]).encrypt();
+      expectResultSuccess(result2);
+    }, 120000);
+  });
+
+  describe('Real Encryption', () => {
+    it('should encrypt a bool with real TFHE', async () => {
+      await cofhesdkClient.connect(publicClient, walletClient);
+
+      const result = await cofhesdkClient.encryptInputs([Encryptable.bool(true)]).encrypt();
+      const encrypted = expectResultSuccess(result);
+
+      expect(encrypted.length).toBe(1);
+      expect(encrypted[0].utype).toBe(FheTypes.Bool);
+      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);
+
+    it('should encrypt all supported types together', async () => {
+      await cofhesdkClient.connect(publicClient, walletClient);
+
+      const inputs = [
+        Encryptable.bool(false),
+        Encryptable.uint8(1n),
+        Encryptable.uint16(2n),
+        Encryptable.uint32(3n),
+        Encryptable.uint64(4n),
+        Encryptable.uint128(5n),
+        Encryptable.address('0x742d35Cc6634C0532925a3b844D16faC4c175E99'),
+      ];
+
+      const result = await cofhesdkClient.encryptInputs(inputs).encrypt();
+      const encrypted = expectResultSuccess(result);
+
+      expect(encrypted.length).toBe(7);
+      // Verify each type
+      expect(encrypted[0].utype).toBe(FheTypes.Bool);
+      expect(encrypted[1].utype).toBe(FheTypes.Uint8);
+      expect(encrypted[2].utype).toBe(FheTypes.Uint16);
+      expect(encrypted[3].utype).toBe(FheTypes.Uint32);
+      expect(encrypted[4].utype).toBe(FheTypes.Uint64);
+      expect(encrypted[5].utype).toBe(FheTypes.Uint128);
+      expect(encrypted[6].utype).toBe(FheTypes.Uint160);
+    }, 90000); // Longer timeout for multiple encryptions
+  });
+
+  describe('Real Builder Pattern', () => {
+    it('should support chaining builder methods with real encryption', async () => {
+      await cofhesdkClient.connect(publicClient, walletClient);
+
+      const snapshot = cofhesdkClient.getSnapshot();
+      const result = await cofhesdkClient
+        .encryptInputs([Encryptable.uint128(100n)])
+        .setChainId(snapshot.chainId!)
+        .setAccount(snapshot.account!)
+        .setSecurityZone(0)
+        .encrypt();
+
+      const encrypted = expectResultSuccess(result);
+      expect(encrypted.length).toBe(1);
+      expect(encrypted[0].utype).toBe(FheTypes.Uint128);
+    }, 60000);
+  });
+
+  describe('Real Error Handling', () => {
+    it('should fail gracefully when not connected', async () => {
+      // Don't connect the client
+      const result = await cofhesdkClient.encryptInputs([Encryptable.uint128(100n)]).encrypt();
+
+      expectResultError(result, CofhesdkErrorCode.NotConnected);
+    }, 30000);
+
+    it('should handle invalid CoFHE URL', async () => {
+      const badConfig = createCofhesdkConfig({
+        supportedChains: [
+          {
+            ...cofhesdkArbSepolia,
+            coFheUrl: 'http://invalid-cofhe-url.local',
+            verifierUrl: 'http://invalid-verifier-url.local',
+          },
+        ],
+        fheKeysPrefetching: 'OFF',
+      });
+
+      const badClient = createCofhesdkClient(badConfig);
+      await badClient.connect(publicClient, walletClient);
+
+      const result = await badClient.encryptInputs([Encryptable.uint128(100n)]).encrypt();
+
+      expect(result.success).toBe(false);
+      if (!result.success) {
+        expect(result.error).toBeDefined();
+      }
+    }, 60000);
+  });
+});

package/node/index.ts

@@ -0,0 +1,96 @@
+// Node.js specific functionality only
+
+import {
+  createCofhesdkClientBase,
+  createCofhesdkConfigBase,
+  type CofhesdkClient,
+  type CofhesdkConfig,
+  type CofhesdkInputConfig,
+  type ZkBuilderAndCrsGenerator,
+  type FheKeyDeserializer,
+} from '@/core';
+
+// Import node-specific storage (internal use only)
+import { createNodeStorage } from './storage.js';
+
+// Import node-tfhe for Node.js
+import { TfheCompactPublicKey, ProvenCompactCiphertextList, CompactPkeCrs, init_panic_hook } from 'node-tfhe';
+
+/**
+ * Internal function to initialize TFHE for Node.js
+ * Called automatically on first encryption - users don't need to call this manually
+ * @returns true if TFHE was initialized, false if already initialized
+ */
+let tfheInitialized = false;
+async function initTfhe(): Promise<boolean> {
+  if (tfheInitialized) return false;
+  await init_panic_hook();
+  tfheInitialized = true;
+  return true;
+}
+
+/**
+ * Utility to convert the hex string key to a Uint8Array for use with tfhe
+ */
+const fromHexString = (hexString: string): Uint8Array => {
+  const cleanString = hexString.length % 2 === 1 ? `0${hexString}` : hexString;
+  const arr = cleanString.replace(/^0x/, '').match(/.{1,2}/g);
+  if (!arr) return new Uint8Array();
+  return new Uint8Array(arr.map((byte) => parseInt(byte, 16)));
+};
+
+/**
+ * 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));
+};
+
+/**
+ * Serializer for Compact PKE CRS
+ * Validates that the buffer can be deserialized into ZkCompactPkePublicParams
+ */
+const compactPkeCrsDeserializer: FheKeyDeserializer = (buff: string): void => {
+  CompactPkeCrs.deserialize(fromHexString(buff));
+};
+
+/**
+ * Creates a ZK builder and CRS from FHE public key and CRS buffers
+ * 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));
+
+  return { zkBuilder, zkCrs };
+};
+
+/**
+ * Creates a CoFHE SDK configuration for Node.js with filesystem storage as default
+ * @param config - The CoFHE SDK input configuration (fheKeyStorage will default to filesystem if not provided)
+ * @returns The CoFHE SDK configuration with Node.js defaults applied
+ */
+export function createCofhesdkConfig(config: CofhesdkInputConfig): CofhesdkConfig {
+  return createCofhesdkConfigBase({
+    ...config,
+    fheKeyStorage: config.fheKeyStorage === null ? null : config.fheKeyStorage ?? createNodeStorage(),
+  });
+}
+
+/**
+ * Creates a CoFHE SDK client instance for Node.js with node-tfhe automatically configured
+ * TFHE will be initialized automatically on first encryption - no manual setup required
+ * @param config - The CoFHE SDK configuration (use createCofhesdkConfig to create with Node.js defaults)
+ * @returns The CoFHE SDK client instance
+ */
+export function createCofhesdkClient(config: CofhesdkConfig): CofhesdkClient {
+  return createCofhesdkClientBase({
+    config,
+    zkBuilderAndCrsGenerator,
+    tfhePublicKeyDeserializer,
+    compactPkeCrsDeserializer,
+    initTfhe,
+  });
+}

package/node/storage.ts

@@ -0,0 +1,51 @@
+/* eslint-disable turbo/no-undeclared-env-vars */
+
+import type { IStorage } from '@/core';
+
+import { promises as fs } from 'fs';
+import { join } from 'path';
+
+// Memory storage fallback
+const memoryStorage: Record<string, string> = {};
+
+/**
+ * Creates a node storage implementation using the filesystem
+ * @returns IStorage implementation for Node.js environments
+ */
+export const createNodeStorage = (): IStorage => {
+  return {
+    getItem: async (name: string) => {
+      try {
+        const storageDir = join(process.env.HOME || process.env.USERPROFILE || '.', '.cofhesdk');
+        await fs.mkdir(storageDir, { recursive: true });
+        const filePath = join(storageDir, `${name}.json`);
+        const data = await fs.readFile(filePath, 'utf8').catch(() => null);
+        return data ? JSON.parse(data) : null;
+      } catch (e) {
+        console.warn('Node.js filesystem modules not available, falling back to memory storage' + e);
+        return memoryStorage[name] || null;
+      }
+    },
+    setItem: async (name: string, value: any) => {
+      try {
+        const storageDir = join(process.env.HOME || process.env.USERPROFILE || '.', '.cofhesdk');
+        await fs.mkdir(storageDir, { recursive: true });
+        const filePath = join(storageDir, `${name}.json`);
+        await fs.writeFile(filePath, JSON.stringify(value));
+      } catch (e) {
+        console.warn('Node.js filesystem modules not available, falling back to memory storage' + e);
+        memoryStorage[name] = JSON.stringify(value);
+      }
+    },
+    removeItem: async (name: string) => {
+      try {
+        const storageDir = join(process.env.HOME || process.env.USERPROFILE || '.', '.cofhesdk');
+        const filePath = join(storageDir, `${name}.json`);
+        await fs.unlink(filePath).catch(() => {});
+      } catch (e) {
+        console.warn('Node.js filesystem modules not available, falling back to memory storage' + e);
+        delete memoryStorage[name];
+      }
+    },
+  };
+};