@cofhe/sdk 0.1.0 → 0.2.0

package/CHANGELOG.md

@@ -0,0 +1,62 @@
+# @cofhe/sdk Changelog
+
+## 0.2.0
+
+### Minor Changes
+
+- 8fda09a: Removes `Promise<boolean>` return type from `client.connect(...)`, instead throws an error if the connection fails.
+- e0caeca: Adds `environment: 'node' | 'web' | 'hardhat' | 'react'` option to config. Exposed via `client.config.enviroment`. Automatically populated appropriately within the various `createCofhesdkConfig` functions.
+- 2a9d6c5: Updated to new CoFHE /sealoutputV2 endpoint - uses polling to fetch decryption results instead of long running open HTTP connections.
+
+### Patch Changes
+
+- 4057a76: Add WebWorker for zkProve
+- dba2759: Add getOrCreate permit functions
+- 7c861af: Remove `initializationResults` from cofhesdk client.
+
+## 0.1.1
+
+### Patch Changes
+
+- a1d1323: Add repository info to package.json of public packages to fix npm publish provenance issue.
+- d232d11: Ensure publish includes correct src and dist files
+- b6521fb: Update publish workflow to create versioning PR upon merge with changeset.
+
+## 0.1.0
+
+### Minor Changes
+
+- 87fc8a0: Initial extraction from cofhejs. Split permit `create` into type specific creators: `createSelf`, `createShared`, and `importShared`
+- 8d41cf2: Combine existing packages into more reasonable defaults. New package layout is @cofhe/sdk (includes all the core logic for configuring and creating a @cofhe/sdk client, encrypting values, and decrypting handles), mock-contracts, hardhat-plugin, and react.
+- 738b9f5: Adding adapters for ethers5/6, Wagmi and HardHat
+- a83facb: Prepare for initial release. Rename scope from `@cofhesdk` to `@cofhe` and rename `cofhesdk` package to `@cofhe/sdk`. Create `publish.yml` to publish `beta` packages on merged PR, and `latest` on changeset PR.
+- 9a7c98e: Create core store, split initialize into `create` and `connect`, and port `encryptInputs` with improvements.
+- 58e93a8: Migrate cofhe-mock-contracts and cofhe-hardhat-plugin into @cofhe/sdk.
+- fdf26d4: Move storage handling to web/node targets; add `fheKeysStorage` config with environment-specific defaults.
+- f5b8e25: Add @cofhe/sdk config type and parsing.
+- 3b135a8: Create @cofhe/sdk/node and @cofhe/sdk/web
+
+  Additional changes:
+
+  - Fhe keys aren't fetched until `client.encryptInputs(...).encrypt()`, they aren't used anywhere else other than encrypting inputs, so their fetching is deferred until then.
+  - Initializing the tfhe wasm is also deferred until `client.encryptInputs(...).encrypt()` is called (allows for deferred async initialization)
+
+- 5b7c43b: Create @cofhe/sdk client, hook in permits.
+  Create encryptInputs functionality. (+ mocks)
+  Create decryptHandles functionality. (+ mocks)
+  Improve @cofhe/sdk errors and error handling.
+
+  fix - seal_output include error_message in failing Error.
+
+### Patch Changes
+
+- cba73fd: Add duration and context information to the step callback function for encryptInputs. Split fetch keys step into InitTfhe and FetchKeys.
+  InitTfhe context includes a `tfheInitializationExecuted` indicating if tfhe was initialized (true) or already initialized (false).
+  FetchKeys returns flags for whether the fhe and crs keys were fetch from remote (true) or from cache (false).
+- 4bc8182: Add storage and key store
+
+This changelog is maintained by Changesets and will be populated on each release.
+
+- Do not edit this file by hand.
+- Upcoming changes can be previewed with `pnpm changeset status --verbose`.
+- Entries are generated when the Changesets "Version Packages" PR is created/merged.

package/adapters/ethers5.test.ts

@@ -0,0 +1,174 @@
+import { describe, it, expect, beforeEach } from 'vitest';
+import { parseEther } from 'viem';
+import { Ethers5Adapter } from './ethers5.js';
+import { createMockEIP1193Provider } from './test-utils.js';
+import * as ethers5 from 'ethers5';
+
+describe('Ethers5Adapter', () => {
+  const testRpcUrl = 'https://ethereum-sepolia.rpc.subquery.network/public';
+  const SEPOLIA_CHAIN_ID = 11155111;
+  let provider: ethers5.providers.JsonRpcProvider;
+  let wallet: ethers5.Wallet;
+
+  beforeEach(() => {
+    // Create common setup for all tests
+    provider = new ethers5.providers.JsonRpcProvider(testRpcUrl);
+    wallet = new ethers5.Wallet('0x' + '1'.repeat(64), provider);
+  });
+
+  it('should work with real JsonRpcProvider and Wallet', async () => {
+    const result = await Ethers5Adapter(provider, wallet);
+
+    expect(result).toHaveProperty('publicClient');
+    expect(result).toHaveProperty('walletClient');
+    expect(result.publicClient).toBeDefined();
+    expect(result.walletClient).toBeDefined();
+  });
+
+  it('should work with Web3Provider signer', async () => {
+    const mockEthereum = createMockEIP1193Provider();
+    const web3Provider = new ethers5.providers.Web3Provider(mockEthereum as any);
+    const wallet = new ethers5.Wallet('0x' + '1'.repeat(64), web3Provider);
+
+    const result = await Ethers5Adapter(web3Provider, wallet);
+
+    expect(result).toHaveProperty('publicClient');
+    expect(result).toHaveProperty('walletClient');
+  });
+
+  it('should work without configuration', async () => {
+    const result = await Ethers5Adapter(provider, wallet);
+
+    expect(result).toHaveProperty('publicClient');
+    expect(result).toHaveProperty('walletClient');
+    expect(result.publicClient).toBeDefined();
+    expect(result.walletClient).toBeDefined();
+  });
+
+  it('should throw error when signer has no provider', async () => {
+    const signerWithoutProvider = { provider: null };
+
+    await expect(async () => {
+      await Ethers5Adapter(signerWithoutProvider as any, wallet);
+    }).rejects.toThrow('Provider does not support EIP-1193 interface');
+  });
+
+  it('should work with real network call', async () => {
+    const result = await Ethers5Adapter(provider, wallet);
+
+    // Test real network call
+    const chainId = await result.publicClient.getChainId();
+    expect(typeof chainId).toBe('number');
+    expect(chainId).toBeGreaterThan(0);
+  }, 10000);
+
+  describe('Provider Functions', () => {
+    it('should support getChainId', async () => {
+      const { publicClient } = await Ethers5Adapter(provider, wallet);
+
+      const chainId = await publicClient.getChainId();
+      expect(typeof chainId).toBe('number');
+      expect(chainId).toBe(SEPOLIA_CHAIN_ID); // Sepolia
+    }, 10000);
+
+    it('should support call (contract read)', async () => {
+      const { publicClient } = await Ethers5Adapter(provider, wallet);
+
+      // Test eth_call - get ETH balance of zero address
+      const balance = await publicClient.getBalance({
+        address: '0x0000000000000000000000000000000000000000',
+      });
+      expect(typeof balance).toBe('bigint');
+    }, 10000);
+
+    it('should support request (raw RPC)', async () => {
+      const { publicClient } = await Ethers5Adapter(provider, wallet);
+
+      // Test raw RPC request - viem requires both method and params
+      const blockNumber = (await publicClient.request({
+        method: 'eth_blockNumber',
+      })) as string;
+      expect(typeof blockNumber).toBe('string');
+      expect(blockNumber.startsWith('0x')).toBe(true);
+    }, 10000);
+  });
+
+  describe('Signer Functions', () => {
+    it('should support getAddress', async () => {
+      const { walletClient } = await Ethers5Adapter(provider, wallet);
+
+      const addresses = await walletClient.getAddresses();
+      expect(Array.isArray(addresses)).toBe(true);
+      // Note: For HTTP transport, this might return empty array
+      // For EIP-1193 providers, it would return actual addresses
+    }, 10000);
+
+    it('should support signTypedData', async () => {
+      const { walletClient } = await Ethers5Adapter(provider, wallet);
+
+      const domain = {
+        name: 'Test',
+        version: '1',
+        chainId: SEPOLIA_CHAIN_ID, // Sepolia
+        verifyingContract: '0x0000000000000000000000000000000000000000' as const,
+      };
+
+      const types = {
+        Message: [{ name: 'content', type: 'string' }],
+      };
+
+      const message = { content: 'Hello World' };
+
+      const signature = await walletClient.signTypedData({
+        domain,
+        types,
+        primaryType: 'Message',
+        message,
+        account: walletClient.account!,
+      });
+
+      expect(typeof signature).toBe('string');
+      expect(signature.startsWith('0x')).toBe(true);
+    }, 10000);
+
+    it('should support sendTransaction', async () => {
+      const { publicClient, walletClient } = await Ethers5Adapter(provider, wallet);
+
+      const account = await walletClient.account;
+      const chain = await publicClient.getChainId();
+
+      console.log('Wallet client ethers5', account, chain);
+
+      // Try to send a transaction - this will fail due to insufficient funds
+      try {
+        console.log('estimating gas');
+        const gas = await publicClient.estimateGas({
+          account: wallet.address as `0x${string}`,
+          to: '0x0000000000000000000000000000000000000000',
+          value: parseEther('0'),
+        });
+
+        console.log('sending transaction', await wallet.getAddress());
+        const hash = await walletClient.sendTransaction({
+          to: '0x0000000000000000000000000000000000000000' as `0x${string}`,
+          value: parseEther('0'),
+          gas,
+          account: walletClient.account!,
+          chain: walletClient.chain,
+        });
+        console.log('transaction sent', hash);
+
+        // If it succeeds (shouldn't due to no funds), verify the format
+        expect(typeof hash).toBe('string');
+        expect(hash.startsWith('0x')).toBe(true);
+        expect(hash.length).toBe(66);
+      } catch (error: any) {
+        // Expected errors: either insufficient funds (good!) or method not supported
+        const isInsufficientFunds = error.message.includes('insufficient funds') || error.message.includes('balance');
+
+        expect(isInsufficientFunds).toBe(true);
+        console.log('Expected error (insufficient funds):', error.message);
+      }
+    }, 10000);
+  });
+});

package/adapters/ethers5.ts

@@ -0,0 +1,36 @@
+import { createPublicClient, createWalletClient, custom } from 'viem';
+import { privateKeyToAccount, toAccount } from 'viem/accounts';
+import type { Signer as AbstractSigner, Wallet, providers } from 'ethers5';
+import { type AdapterResult } from './types.js';
+
+type Ethers5Signer = AbstractSigner | Wallet;
+
+export async function Ethers5Adapter(provider: providers.Provider, signer: Ethers5Signer): Promise<AdapterResult> {
+  // Create transport from provider
+  const transport =
+    provider && 'send' in provider && typeof provider.send === 'function'
+      ? // @ts-ignore - ethers5 provider.send is not typed
+        custom({ request: ({ method, params }: any) => provider.send(method, params ?? []) })
+      : (() => {
+          throw new Error('Provider does not support EIP-1193 interface');
+        })();
+
+  // build a viem Account
+  const address = (await signer.getAddress()) as `0x${string}`;
+  let account: ReturnType<typeof privateKeyToAccount> | ReturnType<typeof toAccount> | `0x${string}`;
+
+  if ('privateKey' in signer && typeof (signer as Wallet).privateKey === 'string') {
+    // Local (true offline) signing → works with Infura via sendRawTransaction
+    account = privateKeyToAccount((signer as Wallet).privateKey as `0x${string}`);
+  } else if (provider && typeof provider.send === 'function') {
+    // Injected wallet (MetaMask/Coinbase) → wallet signs via eth_sendTransaction
+    account = address; // JSON-RPC account (not local signing)
+  } else {
+    throw new Error('Signer does not expose a private key and no injected wallet is available.');
+  }
+
+  const publicClient = createPublicClient({ transport });
+  const walletClient = createWalletClient({ transport, account });
+
+  return { publicClient, walletClient };
+}

package/adapters/ethers6.test.ts

@@ -0,0 +1,169 @@
+import { describe, it, expect, beforeEach } from 'vitest';
+import { parseEther } from 'viem';
+import { Ethers6Adapter } from './ethers6.js';
+import { createMockEIP1193Provider } from './test-utils.js';
+import * as ethers6 from 'ethers6';
+
+describe('Ethers6Adapter', () => {
+  const testRpcUrl = 'https://ethereum-sepolia.rpc.subquery.network/public';
+  const SEPOLIA_CHAIN_ID = 11155111;
+  let provider: ethers6.JsonRpcProvider;
+  let wallet: ethers6.Wallet;
+
+  beforeEach(() => {
+    // Create common setup for all tests
+    provider = new ethers6.JsonRpcProvider(testRpcUrl);
+    wallet = new ethers6.Wallet('0x' + '1'.repeat(64), provider);
+  });
+
+  it('should work with real JsonRpcProvider and Wallet', async () => {
+    const result = await Ethers6Adapter(provider, wallet);
+
+    expect(result).toHaveProperty('publicClient');
+    expect(result).toHaveProperty('walletClient');
+    expect(result.publicClient).toBeDefined();
+    expect(result.walletClient).toBeDefined();
+  });
+
+  it('should work with BrowserProvider signer', async () => {
+    const mockEthereum = createMockEIP1193Provider();
+    const browserProvider = new ethers6.BrowserProvider(mockEthereum as any);
+    const wallet = new ethers6.Wallet('0x' + '1'.repeat(64), browserProvider);
+
+    const result = await Ethers6Adapter(browserProvider, wallet);
+
+    expect(result).toHaveProperty('publicClient');
+    expect(result).toHaveProperty('walletClient');
+  });
+
+  it('should work without configuration', async () => {
+    const result = await Ethers6Adapter(provider, wallet);
+
+    expect(result).toHaveProperty('publicClient');
+    expect(result).toHaveProperty('walletClient');
+    expect(result.publicClient).toBeDefined();
+    expect(result.walletClient).toBeDefined();
+  });
+
+  it('should throw error when signer has no provider', async () => {
+    const signerWithoutProvider = { provider: null };
+
+    await expect(async () => {
+      await Ethers6Adapter(signerWithoutProvider as any, wallet);
+    }).rejects.toThrow('Provider does not support EIP-1193 interface');
+  });
+
+  it('should work with real network call', async () => {
+    const result = await Ethers6Adapter(provider, wallet);
+
+    // Test real network call
+    const chainId = await result.publicClient.getChainId();
+    expect(typeof chainId).toBe('number');
+    expect(chainId).toBeGreaterThan(0);
+  }, 10000);
+
+  describe('Provider Functions', () => {
+    it('should support getChainId', async () => {
+      const { publicClient } = await Ethers6Adapter(provider, wallet);
+
+      const chainId = await publicClient.getChainId();
+      expect(typeof chainId).toBe('number');
+      expect(chainId).toBe(SEPOLIA_CHAIN_ID); // sepolia
+    }, 10000);
+
+    it('should support call (contract read)', async () => {
+      const { publicClient } = await Ethers6Adapter(provider, wallet);
+
+      // Test eth_call - get ETH balance of zero address
+      const balance = await publicClient.getBalance({
+        address: '0x0000000000000000000000000000000000000000',
+      });
+      expect(typeof balance).toBe('bigint');
+    }, 10000);
+
+    it('should support request (raw RPC)', async () => {
+      const { publicClient } = await Ethers6Adapter(provider, wallet);
+
+      // Test raw RPC request - viem requires both method and params
+      const blockNumber = (await publicClient.request({
+        method: 'eth_blockNumber',
+      })) as string;
+      expect(typeof blockNumber).toBe('string');
+      expect(blockNumber.startsWith('0x')).toBe(true);
+    }, 10000);
+  });
+
+  describe('Signer Functions', () => {
+    it('should support getAddress', async () => {
+      const { walletClient } = await Ethers6Adapter(provider, wallet);
+
+      const addresses = await walletClient.getAddresses();
+      expect(Array.isArray(addresses)).toBe(true);
+      // Note: For HTTP transport, this might return empty array
+      // For EIP-1193 providers, it would return actual addresses
+    }, 10000);
+
+    it('should support signTypedData', async () => {
+      const { walletClient } = await Ethers6Adapter(provider, wallet);
+
+      const domain = {
+        name: 'Test',
+        version: '1',
+        chainId: SEPOLIA_CHAIN_ID, // Sepolia
+        verifyingContract: '0x0000000000000000000000000000000000000000' as const,
+      };
+
+      const types = {
+        Message: [{ name: 'content', type: 'string' }],
+      };
+
+      const message = { content: 'Hello World' };
+
+      const signature = await walletClient.signTypedData({
+        domain,
+        types,
+        primaryType: 'Message',
+        message,
+        account: walletClient.account!,
+      });
+
+      expect(typeof signature).toBe('string');
+      expect(signature.startsWith('0x')).toBe(true);
+    }, 10000);
+
+    it('should support sendTransaction', async () => {
+      const { publicClient, walletClient } = await Ethers6Adapter(provider, wallet);
+
+      // Try to send a transaction - this will fail with Infura but we'll catch the error
+      try {
+        console.log('estimating gas');
+        const gas = await publicClient.estimateGas({
+          account: wallet.address as `0x${string}`,
+          to: '0x0000000000000000000000000000000000000000',
+          value: parseEther('0'),
+        });
+
+        console.log('sending transaction', await wallet.getAddress());
+        const hash = await walletClient.sendTransaction({
+          to: '0x0000000000000000000000000000000000000000',
+          value: parseEther('0'),
+          gas,
+          account: walletClient.account!,
+          chain: walletClient.chain,
+        });
+        console.log('transaction sent', hash);
+
+        // If it succeeds (shouldn't with Infura), verify the format
+        expect(typeof hash).toBe('string');
+        expect(hash.startsWith('0x')).toBe(true);
+        expect(hash.length).toBe(66);
+      } catch (error: any) {
+        // Expected errors: either insufficient funds (good!) or method not supported
+        const isInsufficientFunds = error.message.includes('insufficient funds') || error.message.includes('balance');
+
+        expect(isInsufficientFunds).toBe(true);
+        console.log('Expected error (insufficient funds or method not supported):', error.message);
+      }
+    }, 10000);
+  });
+});

package/adapters/ethers6.ts

@@ -0,0 +1,36 @@
+import { createPublicClient, createWalletClient, custom } from 'viem';
+import { privateKeyToAccount, toAccount } from 'viem/accounts';
+import type { Wallet, AbstractSigner, Provider } from 'ethers6';
+import { type AdapterResult } from './types.js';
+
+type Ethers6Signer = AbstractSigner | Wallet;
+
+export async function Ethers6Adapter(provider: Provider, signer: Ethers6Signer): Promise<AdapterResult> {
+  // Create transport from provider
+  const transport =
+    provider && 'send' in provider && typeof provider.send === 'function'
+      ? // @ts-ignore - ethers6 provider.send is not typed
+        custom({ request: ({ method, params }: any) => provider.send(method, params ?? []) })
+      : (() => {
+          throw new Error('Provider does not support EIP-1193 interface');
+        })();
+
+  // build a viem Account
+  const address = (await signer.getAddress()) as `0x${string}`;
+  let account: ReturnType<typeof privateKeyToAccount> | ReturnType<typeof toAccount> | `0x${string}`;
+
+  if ('privateKey' in signer && typeof (signer as Wallet).privateKey === 'string') {
+    // Local (true offline) signing → works with Infura via sendRawTransaction
+    account = privateKeyToAccount((signer as Wallet).privateKey as `0x${string}`); // local account
+  } else if (provider && typeof provider.send === 'function') {
+    // Injected wallet (MetaMask/Coinbase) → wallet signs via eth_sendTransaction
+    account = address; // JSON-RPC account (not local signing)
+  } else {
+    throw new Error('Signer does not expose a private key and no injected wallet is available.');
+  }
+
+  const publicClient = createPublicClient({ transport });
+  const walletClient = createWalletClient({ transport, account });
+
+  return { publicClient, walletClient };
+}

package/adapters/hardhat-node.ts

@@ -0,0 +1,167 @@
+import { spawn, ChildProcess } from 'child_process';
+import { promisify } from 'util';
+import { createConnection } from 'net';
+
+const sleep = promisify(setTimeout);
+
+async function isPortAvailable(port: number): Promise<boolean> {
+  return new Promise((resolve) => {
+    const connection = createConnection({ port, host: '127.0.0.1' });
+
+    connection.on('connect', () => {
+      connection.destroy();
+      resolve(false); // Port is in use
+    });
+
+    connection.on('error', () => {
+      resolve(true); // Port is available
+    });
+  });
+}
+
+async function testHardhatNode(port: number): Promise<boolean> {
+  try {
+    const response = await fetch(`http://127.0.0.1:${port}`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({
+        jsonrpc: '2.0',
+        method: 'eth_chainId',
+        params: [],
+        id: 1,
+      }),
+    });
+
+    if (response.ok) {
+      const data = (await response.json()) as { result: string };
+      // Check if it returns Hardhat's chain ID (31337 = 0x7a69)
+      return data.result === '0x7a69';
+    }
+    return false;
+  } catch {
+    return false;
+  }
+}
+
+export class HardhatNode {
+  private process: ChildProcess | null = null;
+  private isReady = false;
+
+  async start(): Promise<void> {
+    if (this.process) {
+      return; // Already started
+    }
+
+    // Check if port 8545 is already in use
+    const portAvailable = await isPortAvailable(8545);
+    if (!portAvailable) {
+      // Port is in use, check if it's a Hardhat node we can use
+      const isHardhatNode = await testHardhatNode(8545);
+      if (isHardhatNode) {
+        console.log('Found existing Hardhat node on port 8545, using it...');
+        this.isReady = true;
+        return; // Use the existing node
+      } else {
+        throw new Error('Port 8545 is in use by a non-Hardhat service. Please free the port.');
+      }
+    }
+
+    console.log('Starting Hardhat node...');
+
+    this.process = spawn('npx', ['hardhat', 'node'], {
+      cwd: process.cwd(),
+      stdio: ['ignore', 'pipe', 'pipe'],
+    });
+
+    // Wait for the node to be ready
+    await new Promise<void>((resolve, reject) => {
+      const timeout = setTimeout(() => {
+        reject(new Error('Hardhat node failed to start within 30 seconds'));
+      }, 30000);
+
+      const onData = (data: Buffer) => {
+        const output = data.toString();
+        if (output.includes('Started HTTP and WebSocket JSON-RPC server at')) {
+          clearTimeout(timeout);
+          this.isReady = true;
+          console.log('Hardhat node is ready!');
+          resolve();
+        }
+      };
+
+      this.process!.stdout?.on('data', onData);
+      this.process!.stderr?.on('data', onData);
+
+      this.process!.on('error', (error) => {
+        clearTimeout(timeout);
+        reject(error);
+      });
+
+      this.process!.on('exit', (code) => {
+        if (code !== 0 && !this.isReady) {
+          clearTimeout(timeout);
+          reject(new Error(`Hardhat node exited with code ${code}`));
+        }
+      });
+    });
+
+    // Give it a bit more time to be fully ready
+    await sleep(2000);
+  }
+
+  async stop(): Promise<void> {
+    if (this.process) {
+      console.log('Stopping Hardhat node...');
+
+      try {
+        // Immediately force kill - no graceful shutdown to avoid hanging
+        this.process.kill('SIGKILL');
+        this.process = null;
+        this.isReady = false;
+
+        // Quick port cleanup
+        await this.killProcessOnPort(8545);
+
+        console.log('Hardhat node stopped');
+      } catch (error) {
+        console.log('Error stopping node:', error);
+        // Force cleanup regardless
+        this.process = null;
+        this.isReady = false;
+        await this.killProcessOnPort(8545);
+      }
+    } else if (this.isReady) {
+      // We're using an existing node, just mark as not ready
+      console.log('Using external Hardhat node, not stopping it...');
+      this.isReady = false;
+    }
+  }
+
+  isRunning(): boolean {
+    return this.process !== null && this.isReady;
+  }
+
+  private async killProcessOnPort(port: number): Promise<void> {
+    try {
+      const { spawn } = await import('child_process');
+
+      // Kill any process using the port (Linux/macOS) - faster timeout
+      const killProcess = spawn('sh', ['-c', `lsof -ti :${port} | xargs -r kill -9`], {
+        stdio: 'ignore',
+      });
+
+      await new Promise<void>((resolve) => {
+        killProcess.on('exit', () => resolve());
+        killProcess.on('error', () => resolve()); // Ignore errors
+        setTimeout(resolve, 300); // Shorter timeout - 300ms
+      });
+    } catch {
+      // Ignore errors - this is a cleanup attempt
+    }
+  }
+}
+
+// Global instance
+export const hardhatNode = new HardhatNode();
+
+// Global instance - no process handlers to avoid interfering with test process