@cofhe/sdk 0.0.0-alpha-20260409113701

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

package/adapters/hardhat.hh2.test.ts

@@ -0,0 +1,159 @@
+import { describe, it, expect, beforeEach, beforeAll, afterAll } from 'vitest';
+import { parseEther } from 'viem';
+import { hardhat } from 'viem/chains';
+import { HardhatSignerAdapter } from './hardhat.js';
+import hre from 'hardhat';
+import '@nomicfoundation/hardhat-ethers';
+import type { HardhatEthersSigner } from '@nomicfoundation/hardhat-ethers/signers.js';
+import { hardhatNode } from './hardhat-node.js';
+
+describe('HardhatSignerAdapter', () => {
+  const HARDHAT_CHAIN_ID = 31337; // Hardhat local network
+  let signer: HardhatEthersSigner;
+
+  beforeAll(async () => {
+    // Start Hardhat node before running tests
+    // await hardhatNode.start()
+  }, 60000); // 60 second timeout for node startup
+
+  afterAll(async () => {
+    // Immediate cleanup - no waiting
+    console.log('Starting cleanup...');
+    if ((hardhatNode as any).process) {
+      try {
+        (hardhatNode as any).process.kill('SIGKILL');
+        (hardhatNode as any).process = null;
+        (hardhatNode as any).isReady = false;
+      } catch (e) {
+        console.log('Kill error:', e);
+      }
+    }
+
+    // Force port cleanup
+    try {
+      const { spawn } = await import('child_process');
+      const killCmd = spawn('sh', ['-c', 'lsof -ti :8545 | xargs -r kill -9'], { stdio: 'ignore' });
+      setTimeout(() => killCmd.kill('SIGKILL'), 1000); // Kill the kill command after 1s
+    } catch (e) {
+      console.log('Port cleanup error:', e);
+    }
+
+    console.log('Cleanup done');
+  }, 3000); // 3 second timeout
+
+  beforeEach(async () => {
+    // Use real Hardhat runtime environment
+    const [firstSigner] = await hre.ethers.getSigners();
+    signer = firstSigner;
+  });
+
+  it('should work with Hardhat signer', async () => {
+    const result = await HardhatSignerAdapter(signer);
+
+    expect(result).toHaveProperty('publicClient');
+    expect(result).toHaveProperty('walletClient');
+    expect(result.publicClient).toBeDefined();
+    expect(result.walletClient).toBeDefined();
+  });
+
+  it('should work without configuration', async () => {
+    const result = await HardhatSignerAdapter(signer);
+
+    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 HardhatSignerAdapter(signerWithoutProvider as any);
+    }).rejects.toThrow('Signer must have a provider');
+  });
+
+  describe('Provider Functions', () => {
+    it('should support getChainId', async () => {
+      const { publicClient } = await HardhatSignerAdapter(signer);
+
+      const chainId = await publicClient.getChainId();
+      expect(typeof chainId).toBe('number');
+      expect(chainId).toBe(HARDHAT_CHAIN_ID); // Hardhat local network
+    });
+
+    it('should support call (contract read)', async () => {
+      const { publicClient } = await HardhatSignerAdapter(signer);
+
+      // Test eth_call via getBalance
+      const balance = await publicClient.getBalance({
+        address: '0x0000000000000000000000000000000000000000',
+      });
+      expect(typeof balance).toBe('bigint');
+    });
+
+    it('should support request (raw RPC)', async () => {
+      const { publicClient } = await HardhatSignerAdapter(signer);
+
+      // Test raw RPC request
+      const blockNumber = (await publicClient.request({
+        method: 'eth_blockNumber',
+      })) as string;
+      expect(typeof blockNumber).toBe('string');
+      expect(blockNumber.startsWith('0x')).toBe(true);
+    });
+  });
+
+  describe('Signer Functions', () => {
+    it('should support getAddress', async () => {
+      const { walletClient } = await HardhatSignerAdapter(signer);
+
+      const addresses = await walletClient.getAddresses();
+      expect(Array.isArray(addresses)).toBe(true);
+    });
+
+    it('should support signTypedData', async () => {
+      const { walletClient } = await HardhatSignerAdapter(signer);
+
+      const domain = {
+        name: 'Test',
+        version: '1',
+        chainId: HARDHAT_CHAIN_ID,
+        verifyingContract: '0x0000000000000000000000000000000000000000' as const,
+      };
+
+      const types = {
+        Message: [{ name: 'content', type: 'string' }],
+      };
+
+      const message = { content: 'Hello World' };
+
+      const signature = await walletClient.signTypedData({
+        account: (await signer.getAddress()) as `0x${string}`,
+        domain,
+        types,
+        primaryType: 'Message',
+        message,
+      });
+
+      expect(typeof signature).toBe('string');
+      expect(signature.startsWith('0x')).toBe(true);
+    });
+
+    it('should support sendTransaction', async () => {
+      const { walletClient } = await HardhatSignerAdapter(signer);
+
+      const hash = await walletClient.sendTransaction({
+        account: (await signer.getAddress()) as `0x${string}`,
+        to: '0x0000000000000000000000000000000000000000' as `0x${string}`,
+        value: parseEther('0'),
+        chain: hardhat, // Provide chain directly in the call
+      });
+
+      // Should succeed with Hardhat local network (has funds)
+      expect(typeof hash).toBe('string');
+      expect(hash.startsWith('0x')).toBe(true);
+      expect(hash.length).toBe(66);
+    });
+  });
+});

package/adapters/hardhat.ts

@@ -0,0 +1,36 @@
+import { createPublicClient, createWalletClient, custom } from 'viem';
+import { type AdapterResult } from './types.js';
+import type { HardhatEthersSigner } from '@nomicfoundation/hardhat-ethers/signers.js';
+
+export async function HardhatSignerAdapter(signer: HardhatEthersSigner): Promise<AdapterResult> {
+  // Get provider from signer
+  const provider = signer.provider;
+  if (!provider) {
+    throw new Error('Signer must have a provider');
+  }
+
+  // Create transport from provider (Hardhat providers are EIP-1193 compatible)
+  const transport = custom({
+    request: async ({ method, params }: { method: string; params?: unknown[] }) => {
+      if ('request' in provider && typeof provider.request === 'function') {
+        return await provider.request({ method, params });
+      } else if ('send' in provider && typeof provider.send === 'function') {
+        return await (provider as { send: (method: string, params?: unknown[]) => Promise<unknown> }).send(
+          method,
+          params || []
+        );
+      } else {
+        throw new Error('Provider does not support EIP-1193 request method');
+      }
+    },
+  });
+
+  // Get account from signer for local signing
+  const address = await signer.getAddress();
+  const account = address as `0x${string}`;
+
+  const publicClient = createPublicClient({ transport });
+  const walletClient = createWalletClient({ transport, account });
+
+  return { publicClient, walletClient };
+}

package/adapters/index.test.ts

@@ -0,0 +1,20 @@
+import { describe, it, expect } from 'vitest';
+import * as adapters from './index.js';
+
+describe('Index Exports', () => {
+  it('should export main adapter functions', () => {
+    expect(typeof adapters.Ethers5Adapter).toBe('function');
+    expect(typeof adapters.Ethers6Adapter).toBe('function');
+    expect(typeof adapters.WagmiAdapter).toBe('function');
+    expect(typeof adapters.HardhatSignerAdapter).toBe('function');
+  });
+
+  it('should have the expected simple adapters', () => {
+    const expectedAdapters = ['Ethers5Adapter', 'Ethers6Adapter', 'WagmiAdapter', 'HardhatSignerAdapter'];
+
+    expectedAdapters.forEach((adapterName) => {
+      expect(adapters).toHaveProperty(adapterName);
+      expect(typeof (adapters as any)[adapterName]).toBe('function');
+    });
+  });
+});

package/adapters/index.ts

@@ -0,0 +1,5 @@
+export { Ethers5Adapter } from './ethers5.js';
+export { Ethers6Adapter } from './ethers6.js';
+export { WagmiAdapter } from './wagmi.js';
+export { HardhatSignerAdapter } from './hardhat.js';
+export type { AdapterResult } from './types.js';

package/adapters/smartWallet.ts

@@ -0,0 +1,99 @@
+import type { PublicClient, WalletClient, Chain, Hex } from 'viem';
+import { createWalletClient, custom } from 'viem';
+
+type SmartAccountClient = {
+  account: { address: `0x${string}` };
+  // Sends a UserOperation, returns a hash (usually userOpHash)
+  sendTransaction: (tx: any) => Promise<`0x${string}`>;
+  // EIP-712 via smart account (e.g., Safe EIP-1271)
+  signTypedData: (_args: {
+    domain: any;
+    types: Record<string, any>;
+    primaryType: string;
+    message: Record<string, any>;
+  }) => Promise<`0x${string}`>;
+  // Optional:
+  signMessage?: (_args: { message: string | Hex }) => Promise<`0x${string}`>;
+};
+
+/**
+ * Adapter: (publicClient, smartAccountClient) -> { publicClient, walletClient }
+ * - publicClient: passthrough of the given viem PublicClient
+ * - walletClient: viem WalletClient-shaped object whose sendTransaction/sign* delegate to the smart account
+ */
+export function smartWalletViemAdapter(
+  publicClient: PublicClient,
+  smartAccountClient: SmartAccountClient,
+  opts: { chain?: Chain } = {}
+): { publicClient: PublicClient; walletClient: WalletClient } {
+  const chain = opts.chain ?? (publicClient as any).chain;
+
+  // Use the existing publicClient for all JSON-RPC calls
+  const transport = custom({
+    request: ({ method, params }: { method: string; params?: any[] }) =>
+      publicClient.request({ method: method as any, params: (params ?? []) as any }),
+  });
+
+  // Create a base viem WalletClient (JSON-RPC account placeholder)
+  // We’ll override methods to route through the smart account.
+  const base = createWalletClient({
+    chain,
+    transport,
+    account: smartAccountClient.account.address, // not used for signing; just keeps API shape
+  });
+
+  // Override methods that must go through the smart account
+  const walletClient: WalletClient = {
+    ...base,
+
+    /**
+     * For AA, this sends a UserOperation via your smartAccountClient.
+     * Return value is typically a userOp hash (not a raw tx hash).
+     */
+    async sendTransaction(tx: any) {
+      return smartAccountClient.sendTransaction(tx);
+    },
+
+    /**
+     * Sign typed data via the smart account (EIP-1271 flow).
+     * Supports both single-object and (domain, types, message) forms.
+     */
+    async signTypedData(arg1: any, types?: any, message?: any) {
+      let domain, typesObj, messageObj, primaryType: string;
+      if (types === undefined && message === undefined) {
+        // Single object: { domain, types, message, primaryType }
+        domain = arg1.domain;
+        typesObj = arg1.types;
+        messageObj = arg1.message;
+        primaryType = arg1.primaryType;
+      } else {
+        // Separate params
+        domain = arg1;
+        typesObj = types;
+        messageObj = message;
+        primaryType = Object.keys(typesObj).find((k) => k !== 'EIP712Domain') ?? Object.keys(typesObj)[0];
+      }
+      return smartAccountClient.signTypedData({ domain, types: typesObj, primaryType, message: messageObj });
+    },
+
+    /**
+     * Optional message signing if your smart account client supports it.
+     * Otherwise, fall back to base (may throw for smart accounts).
+     */
+    async signMessage(args: { message: string | Hex }) {
+      if (typeof smartAccountClient.signMessage === 'function') {
+        return smartAccountClient.signMessage(args);
+      }
+      // Fallback to base signMessage if smart account doesn't support it
+      return base.signMessage({ ...args, account: base.account });
+    },
+
+    /**
+     * Smart accounts generally cannot produce a raw signed EOA tx.
+     * Keep viem’s default, but expect it to throw if invoked.
+     */
+    // signTransaction: base.signTransaction,
+  } as WalletClient;
+
+  return { publicClient, walletClient };
+}

package/adapters/test-utils.ts

@@ -0,0 +1,53 @@
+import { vi } from 'vitest';
+import type { EIP1193Provider } from 'viem';
+
+/**
+ * Mock EIP-1193 provider for testing
+ */
+export function createMockEIP1193Provider(): EIP1193Provider {
+  const mockProvider = {
+    request: vi.fn().mockImplementation(async ({ method, params }) => {
+      switch (method) {
+        case 'eth_chainId':
+          return '0x2aa36a7'; // Sepolia chainId
+        case 'eth_accounts':
+          return ['0x742d35Cc6634C0532925a3b8D0Ea4E686C9b8A'];
+        case 'eth_getBalance':
+          return '0x1bc16d674ec80000'; // 2 ETH
+        case 'eth_blockNumber':
+          return '0x12345';
+        case 'eth_gasPrice':
+          return '0x9184e72a000'; // 10 gwei
+        case 'personal_sign':
+        case 'eth_sign':
+          return '0x' + 'a'.repeat(130); // Mock signature
+        case 'eth_signTypedData_v4':
+          return '0x' + 'a'.repeat(130); // Mock typed data signature
+        case 'eth_sendTransaction':
+          return '0x' + 'b'.repeat(64); // Mock transaction hash
+        default:
+          throw new Error(`Unsupported method: ${method}`);
+      }
+    }),
+    on: vi.fn(),
+    removeListener: vi.fn(),
+    // Add additional EIP-1193 properties
+    send: vi.fn(),
+    sendAsync: vi.fn(),
+    isMetaMask: false,
+    isConnected: vi.fn().mockReturnValue(true),
+  };
+
+  // Add bind method that viem expects and bind all methods
+  const boundProvider = {
+    ...mockProvider,
+    request: mockProvider.request.bind(mockProvider),
+    on: mockProvider.on.bind(mockProvider),
+    removeListener: mockProvider.removeListener.bind(mockProvider),
+    bind: function () {
+      return this;
+    },
+  };
+
+  return boundProvider as any;
+}

package/adapters/types.ts

@@ -0,0 +1,6 @@
+import type { PublicClient, WalletClient } from 'viem';
+
+export interface AdapterResult {
+  publicClient: PublicClient;
+  walletClient: WalletClient;
+}