@cofhe/sdk 0.1.0 → 0.2.0

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;
+}

package/adapters/wagmi.test.ts

@@ -0,0 +1,156 @@
+import { describe, it, expect, beforeEach } from 'vitest';
+import { parseEther, createPublicClient, createWalletClient, http, type PublicClient, type WalletClient } from 'viem';
+import { privateKeyToAccount } from 'viem/accounts';
+import { WagmiAdapter } from './wagmi.js';
+
+describe('WagmiAdapter', () => {
+  const testRpcUrl = 'https://ethereum-sepolia.rpc.subquery.network/public';
+  const SEPOLIA_CHAIN_ID = 11155111;
+  let account: ReturnType<typeof privateKeyToAccount>;
+  let publicClient: PublicClient;
+  let walletClient: WalletClient;
+
+  beforeEach(() => {
+    // Create common setup for all tests - no chain needed
+    account = privateKeyToAccount(('0x' + '1'.repeat(64)) as `0x${string}`);
+
+    publicClient = createPublicClient({
+      transport: http(testRpcUrl),
+    });
+
+    walletClient = createWalletClient({
+      transport: http(testRpcUrl),
+      account,
+    });
+  });
+
+  it('should work with real Wagmi clients', async () => {
+    const result = await WagmiAdapter(walletClient, publicClient);
+
+    expect(result).toHaveProperty('publicClient');
+    expect(result).toHaveProperty('walletClient');
+    expect(result.publicClient).toBe(publicClient);
+    expect(result.walletClient).toBe(walletClient);
+  });
+
+  it('should throw error when wallet client is missing', async () => {
+    const mockPublicClient = {} as any;
+
+    await expect(async () => {
+      await WagmiAdapter(null as any, mockPublicClient);
+    }).rejects.toThrow('WalletClient is required');
+  });
+
+  it('should throw error when public client is missing', async () => {
+    const mockWalletClient = {} as any;
+
+    await expect(async () => {
+      await WagmiAdapter(mockWalletClient, null as any);
+    }).rejects.toThrow('PublicClient is required');
+  });
+
+  describe('Provider Functions', () => {
+    it('should support getChainId', async () => {
+      const { publicClient: resultPublic } = await WagmiAdapter(walletClient, publicClient);
+
+      const chainId = await resultPublic.getChainId();
+      expect(typeof chainId).toBe('number');
+      expect(chainId).toBe(SEPOLIA_CHAIN_ID);
+    }, 10000);
+
+    it('should support call (contract read)', async () => {
+      const { publicClient: resultPublic } = await WagmiAdapter(walletClient, publicClient);
+
+      // Test eth_call - get ETH balance of zero address
+      const balance = await resultPublic.getBalance({
+        address: '0x0000000000000000000000000000000000000000',
+      });
+      expect(typeof balance).toBe('bigint');
+    }, 10000);
+
+    it('should support request (raw RPC)', async () => {
+      const { publicClient: resultPublic } = await WagmiAdapter(walletClient, publicClient);
+
+      // Test raw RPC request
+      const blockNumber = (await resultPublic.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: resultWallet } = await WagmiAdapter(walletClient, publicClient);
+
+      const addresses = await resultWallet.getAddresses();
+      expect(Array.isArray(addresses)).toBe(true);
+      // Should contain the account address
+      expect(addresses).toContain(account.address);
+    }, 10000);
+
+    it('should support signTypedData', async () => {
+      const { walletClient: resultWallet } = await WagmiAdapter(walletClient, publicClient);
+
+      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 resultWallet.signTypedData({
+        domain,
+        types,
+        primaryType: 'Message',
+        message,
+        account: resultWallet.account!,
+      });
+
+      expect(typeof signature).toBe('string');
+      expect(signature.startsWith('0x')).toBe(true);
+    }, 10000);
+
+    it('should support sendTransaction', async () => {
+      const { publicClient: resultPublic, walletClient: resultWallet } = await WagmiAdapter(walletClient, publicClient);
+
+      // Try to send a transaction - this will fail due to insufficient funds
+      try {
+        console.log('estimating gas');
+        const gas = await resultPublic.estimateGas({
+          account: account.address,
+          to: '0x0000000000000000000000000000000000000000',
+          value: parseEther('0'),
+        });
+
+        console.log('sending transaction', account.address);
+        const hash = await resultWallet.sendTransaction({
+          to: '0x0000000000000000000000000000000000000000' as `0x${string}`,
+          value: parseEther('0'),
+          gas,
+          account: resultWallet.account!,
+          chain: resultWallet.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 error: insufficient funds (good!)
+        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/wagmi.ts

@@ -0,0 +1,17 @@
+import { type PublicClient, type WalletClient } from 'viem';
+
+export async function WagmiAdapter(walletClient: WalletClient, publicClient: PublicClient) {
+  if (!walletClient) {
+    throw new Error('WalletClient is required');
+  }
+
+  if (!publicClient) {
+    throw new Error('PublicClient is required');
+  }
+
+  // Wagmi provides real viem clients, so we just pass them through
+  return {
+    publicClient,
+    walletClient,
+  };
+}

package/chains/chains/arbSepolia.ts

@@ -0,0 +1,14 @@
+import { defineChain } from '../defineChain.js';
+
+/**
+ * Arbitrum Sepolia testnet chain configuration
+ */
+export const arbSepolia = defineChain({
+  id: 421614,
+  name: 'Arbitrum Sepolia',
+  network: 'arb-sepolia',
+  coFheUrl: 'https://testnet-cofhe.fhenix.zone',
+  verifierUrl: 'https://testnet-cofhe-vrf.fhenix.zone',
+  thresholdNetworkUrl: 'https://testnet-cofhe-tn.fhenix.zone',
+  environment: 'TESTNET',
+});

package/chains/chains/baseSepolia.ts

@@ -0,0 +1,14 @@
+import { defineChain } from '../defineChain.js';
+
+/**
+ * Base Sepolia testnet chain configuration
+ */
+export const baseSepolia = defineChain({
+  id: 84532,
+  name: 'Base Sepolia',
+  network: 'base-sepolia',
+  coFheUrl: 'https://testnet-cofhe.fhenix.zone',
+  verifierUrl: 'https://testnet-cofhe-vrf.fhenix.zone',
+  thresholdNetworkUrl: 'https://testnet-cofhe-tn.fhenix.zone',
+  environment: 'TESTNET',
+});

package/chains/chains/hardhat.ts

@@ -0,0 +1,15 @@
+import { defineChain } from '../defineChain.js';
+
+/**
+ * Hardhat local development chain configuration
+ */
+export const hardhat = defineChain({
+  id: 31337,
+  name: 'Hardhat',
+  network: 'localhost',
+  // These are unused in the mock environment
+  coFheUrl: 'http://127.0.0.1:8448',
+  verifierUrl: 'http://127.0.0.1:3001',
+  thresholdNetworkUrl: 'http://127.0.0.1:3000',
+  environment: 'MOCK',
+});

package/chains/chains/localcofhe.ts

@@ -0,0 +1,14 @@
+import { defineChain } from '../defineChain.js';
+
+/**
+ * Localcofhe chain configuration
+ */
+export const localcofhe = defineChain({
+  id: 420105,
+  name: 'Local Cofhe',
+  network: 'localhost',
+  coFheUrl: 'http://127.0.0.1:9448',
+  verifierUrl: 'http://127.0.0.1:3001',
+  thresholdNetworkUrl: 'http://127.0.0.1:3000',
+  environment: 'TESTNET',
+});

package/chains/chains/sepolia.ts

@@ -0,0 +1,14 @@
+import { defineChain } from '../defineChain.js';
+
+/**
+ * Sepolia testnet chain configuration
+ */
+export const sepolia = defineChain({
+  id: 11155111,
+  name: 'Sepolia',
+  network: 'sepolia',
+  coFheUrl: 'https://testnet-cofhe.fhenix.zone',
+  verifierUrl: 'https://testnet-cofhe-vrf.fhenix.zone',
+  thresholdNetworkUrl: 'https://testnet-cofhe-tn.fhenix.zone',
+  environment: 'TESTNET',
+});