@cofhe/sdk 0.0.0-alpha-20260409113701

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',
+});

package/chains/chains.test.ts

@@ -0,0 +1,50 @@
+import { describe, it, expect } from 'vitest';
+import { sepolia, arbSepolia, baseSepolia, hardhat, chains, getChainById, getChainByName } from './index.js';
+
+describe('Chains', () => {
+  it('should export all chains', () => {
+    expect(Object.keys(chains)).toHaveLength(5);
+    expect(chains).toHaveProperty('sepolia');
+    expect(chains).toHaveProperty('arbSepolia');
+    expect(chains).toHaveProperty('baseSepolia');
+    expect(chains).toHaveProperty('hardhat');
+    expect(chains).toHaveProperty('localcofhe');
+  });
+
+  it('should have correct chain configurations', () => {
+    expect(sepolia.id).toBe(11155111);
+    expect(sepolia.name).toBe('Sepolia');
+    expect(sepolia.environment).toBe('TESTNET');
+
+    expect(hardhat.id).toBe(31337);
+    expect(hardhat.name).toBe('Hardhat');
+    expect(hardhat.environment).toBe('MOCK');
+  });
+
+  it('should find chains by ID', () => {
+    expect(getChainById(11155111)).toBe(sepolia);
+    expect(getChainById(31337)).toBe(hardhat);
+    expect(getChainById(999999)).toBeUndefined();
+  });
+
+  it('should find chains by name', () => {
+    expect(getChainByName('sepolia')).toBe(sepolia);
+    expect(getChainByName('Sepolia')).toBe(sepolia);
+    expect(getChainByName('hardhat')).toBe(hardhat);
+    expect(getChainByName('nonexistent')).toBeUndefined();
+  });
+
+  it('should validate chain properties', () => {
+    const allChains = [sepolia, arbSepolia, baseSepolia, hardhat];
+
+    allChains.forEach((chain) => {
+      expect(typeof chain.id).toBe('number');
+      expect(typeof chain.name).toBe('string');
+      expect(typeof chain.network).toBe('string');
+      expect(typeof chain.coFheUrl).toBe('string');
+      expect(typeof chain.verifierUrl).toBe('string');
+      expect(typeof chain.thresholdNetworkUrl).toBe('string');
+      expect(['MOCK', 'TESTNET', 'MAINNET']).toContain(chain.environment);
+    });
+  });
+});

package/chains/defineChain.ts

@@ -0,0 +1,18 @@
+import { CofheChainSchema, type CofheChain } from './types.js';
+import { z } from 'zod';
+
+/**
+ * Defines and validates a CofheChain configuration
+ * @param chainConfig - The chain configuration object to validate
+ * @returns The validated chain configuration unchanged
+ * @throws {Error} If the chain configuration is invalid
+ */
+export function defineChain(chainConfig: CofheChain): CofheChain {
+  const result = CofheChainSchema.safeParse(chainConfig);
+
+  if (!result.success) {
+    throw new Error(`Invalid chain configuration: ${z.prettifyError(result.error)}`, { cause: result.error });
+  }
+
+  return result.data;
+}

package/chains/index.ts

@@ -0,0 +1,35 @@
+// Export types
+export type { CofheChain, Environment } from './types.js';
+
+// Import and export individual chains
+import { sepolia } from './chains/sepolia.js';
+import { arbSepolia } from './chains/arbSepolia.js';
+import { baseSepolia } from './chains/baseSepolia.js';
+import { hardhat } from './chains/hardhat.js';
+import { localcofhe } from './chains/localcofhe.js';
+
+export { sepolia, arbSepolia, baseSepolia, hardhat, localcofhe };
+
+// Export all chains as a collection
+export const chains = {
+  sepolia,
+  arbSepolia,
+  baseSepolia,
+  hardhat,
+  localcofhe,
+} as const;
+
+// Import CofheChain type for helper functions
+import type { CofheChain } from './types.js';
+
+// Export chain by ID helper
+export const getChainById = (chainId: number): CofheChain | undefined => {
+  return Object.values(chains).find((chain) => chain.id === chainId);
+};
+
+// Export chain by name helper
+export const getChainByName = (name: string): CofheChain | undefined => {
+  return Object.values(chains).find(
+    (chain) => chain.name.toLowerCase() === name.toLowerCase() || chain.network.toLowerCase() === name.toLowerCase()
+  );
+};

package/chains/types.ts

@@ -0,0 +1,32 @@
+import { z } from 'zod';
+
+/**
+ * Environment schema for @cofhe/sdk chains
+ */
+export const EnvironmentSchema = z.enum(['MOCK', 'TESTNET', 'MAINNET']);
+
+/**
+ * Zod schema for CofheChain validation
+ */
+export const CofheChainSchema = z.object({
+  /** Chain ID */
+  id: z.number().int().positive(),
+  /** Human-readable chain name */
+  name: z.string().min(1),
+  /** Network identifier */
+  network: z.string().min(1),
+  /** coFhe service URL */
+  coFheUrl: z.url(),
+  /** Verifier service URL */
+  verifierUrl: z.url(),
+  /** Threshold network service URL */
+  thresholdNetworkUrl: z.url(),
+  /** Environment type */
+  environment: EnvironmentSchema,
+});
+
+/**
+ * Type inference from the schema
+ */
+export type CofheChain = z.infer<typeof CofheChainSchema>;
+export type Environment = z.infer<typeof EnvironmentSchema>;

package/core/baseBuilder.ts

@@ -0,0 +1,119 @@
+import { type PublicClient, type WalletClient } from 'viem';
+import { type CofheConfig } from './config.js';
+import { CofheError, CofheErrorCode } from './error.js';
+
+/**
+ * Base parameters that all builders need
+ */
+export type BaseBuilderParams = {
+  config: CofheConfig | undefined;
+  publicClient: PublicClient | undefined;
+  walletClient: WalletClient | undefined;
+
+  chainId: number | undefined;
+  account: string | undefined;
+
+  requireConnected: (() => void) | undefined;
+};
+
+/**
+ * Abstract base class for builders that provides common functionality
+ * for working with clients, config, and chain IDs
+ */
+export abstract class BaseBuilder {
+  protected config: CofheConfig;
+
+  protected publicClient: PublicClient | undefined;
+  protected walletClient: WalletClient | undefined;
+
+  protected chainId: number | undefined;
+  protected account: string | undefined;
+
+  constructor(params: BaseBuilderParams) {
+    // Check that config is provided
+    if (!params.config) {
+      throw new CofheError({
+        code: CofheErrorCode.MissingConfig,
+        message: 'Builder config is undefined',
+        hint: 'Ensure client has been created with a config.',
+        context: {
+          config: params.config,
+        },
+      });
+    }
+    this.config = params.config;
+
+    this.publicClient = params.publicClient;
+    this.walletClient = params.walletClient;
+
+    this.chainId = params.chainId;
+    this.account = params.account;
+
+    // Require the client to be connected if passed as param
+    params.requireConnected?.();
+  }
+
+  /**
+   * Asserts that this.chainId is populated
+   * @throws {CofheError} If chainId is not set
+   */
+  protected assertChainId(): asserts this is this & { chainId: number } {
+    if (this.chainId) return;
+    throw new CofheError({
+      code: CofheErrorCode.ChainIdUninitialized,
+      message: 'Chain ID is not set',
+      hint: 'Ensure client.connect() has been called and awaited, or use setChainId(...) to set the chainId explicitly.',
+      context: {
+        chainId: this.chainId,
+      },
+    });
+  }
+
+  /**
+   * Asserts that this.account is populated
+   * @throws {CofheError} If account is not set
+   */
+  protected assertAccount(): asserts this is this & { account: string } {
+    if (this.account) return;
+    throw new CofheError({
+      code: CofheErrorCode.AccountUninitialized,
+      message: 'Account is not set',
+      hint: 'Ensure client.connect() has been called and awaited, or use setAccount(...) to set the account explicitly.',
+      context: {
+        account: this.account,
+      },
+    });
+  }
+
+  /**
+   * Asserts that this.publicClient is populated
+   * @throws {CofheError} If publicClient is not set
+   */
+  protected assertPublicClient(): asserts this is this & { publicClient: PublicClient } {
+    if (this.publicClient) return;
+    throw new CofheError({
+      code: CofheErrorCode.MissingPublicClient,
+      message: 'Public client not found',
+      hint: 'Ensure client.connect() has been called with a publicClient.',
+      context: {
+        publicClient: this.publicClient,
+      },
+    });
+  }
+
+  /**
+   * Asserts that this.walletClient is populated
+   * @throws {CofheError} If walletClient is not set
+   */
+  protected assertWalletClient(): asserts this is this & { walletClient: WalletClient } {
+    if (this.walletClient) return;
+    throw new CofheError({
+      code: CofheErrorCode.MissingWalletClient,
+      message: 'Wallet client not found',
+      hint: 'Ensure client.connect() has been called with a walletClient.',
+      context: {
+        walletClient: this.walletClient,
+      },
+    });
+  }
+}