@cofhe/sdk 0.1.1 → 0.2.0

package/CHANGELOG.md

@@ -1,5 +1,19 @@
 # @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

package/adapters/ethers6.ts

@@ -1,36 +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'
+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
+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')
-				})()
+  // 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}`
+  // 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.')
-	}
+  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 })
+  const publicClient = createPublicClient({ transport });
+  const walletClient = createWalletClient({ transport, account });
 
-	return { publicClient, walletClient }
+  return { publicClient, walletClient };
 }

package/adapters/hardhat.ts

@@ -1,4 +1,3 @@
-/* eslint-disable no-unused-vars */
 import { createPublicClient, createWalletClient, custom } from 'viem';
 import { type AdapterResult } from './types.js';
 import type { HardhatEthersSigner } from '@nomicfoundation/hardhat-ethers/signers.js';

package/adapters/index.test.ts

@@ -1,25 +1,20 @@
-import { describe, it, expect } from 'vitest'
-import * as adapters from './index.js'
+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')
-  })
+    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'
-    ]
+    const expectedAdapters = ['Ethers5Adapter', 'Ethers6Adapter', 'WagmiAdapter', 'HardhatSignerAdapter'];
 
-    expectedAdapters.forEach(adapterName => {
-      expect(adapters).toHaveProperty(adapterName)
-      expect(typeof (adapters as any)[adapterName]).toBe('function')
-    })
-  })
-})
+    expectedAdapters.forEach((adapterName) => {
+      expect(adapters).toHaveProperty(adapterName);
+      expect(typeof (adapters as any)[adapterName]).toBe('function');
+    });
+  });
+});

package/adapters/smartWallet.ts

@@ -1,16 +1,19 @@
-import type { PublicClient, WalletClient, Chain, Hex } from "viem";
-import { createWalletClient, custom } from "viem";
-
+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)
-    // eslint-disable-next-line no-unused-vars
-    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}`>;
+  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}`>;
 };
 
 /**
@@ -18,74 +21,79 @@ type SmartAccountClient = {
  * - 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;
+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 }),
-    });
+  // 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
-    });
+  // 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,
+  // 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);
-        },
+    /**
+     * 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 });
-        },
+    /**
+     * 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 });
-        },
+    /**
+     * 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;
+    /**
+     * 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 };
+  return { publicClient, walletClient };
 }

package/adapters/test-utils.ts

@@ -1,53 +1,53 @@
-import { vi } from 'vitest'
-import type { EIP1193Provider } from 'viem'
+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),
-	}
+  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
-		},
-	}
+  // 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
+  return boundProvider as any;
 }

package/adapters/types.ts

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

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.test.ts

@@ -3,11 +3,12 @@ import { sepolia, arbSepolia, baseSepolia, hardhat, chains, getChainById, getCha
 
 describe('Chains', () => {
   it('should export all chains', () => {
-    expect(Object.keys(chains)).toHaveLength(4);
+    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', () => {

package/chains/index.ts

@@ -6,8 +6,9 @@ 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 };
+export { sepolia, arbSepolia, baseSepolia, hardhat, localcofhe };
 
 // Export all chains as a collection
 export const chains = {
@@ -15,6 +16,7 @@ export const chains = {
   arbSepolia,
   baseSepolia,
   hardhat,
+  localcofhe,
 } as const;
 
 // Import CofheChain type for helper functions

package/core/baseBuilder.ts

@@ -21,34 +21,44 @@ export type BaseBuilderParams = {
  * for working with clients, config, and chain IDs
  */
 export abstract class BaseBuilder {
-  protected config: CofhesdkConfig | undefined;
+  protected config: CofhesdkConfig;
+
   protected publicClient: PublicClient | undefined;
   protected walletClient: WalletClient | undefined;
 
   protected chainId: number | undefined;
   protected account: string | undefined;
 
-  protected requireConnected: (() => void) | undefined;
-
   constructor(params: BaseBuilderParams) {
+    // Check that config is provided
+    if (!params.config) {
+      throw new CofhesdkError({
+        code: CofhesdkErrorCode.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;
 
-    this.requireConnected = params.requireConnected;
+    // Require the client to be connected if passed as param
+    params.requireConnected?.();
   }
 
   /**
-   * Gets the chain ID from the instance or fetches it from the public client
-   * @returns The chain ID
-   * @throws {CofhesdkError} If chainId is not set and publicClient is not available
+   * Asserts that this.chainId is populated
+   * @throws {CofhesdkError} If chainId is not set
    */
-  protected async getChainIdOrThrow(): Promise<number> {
-    if (this.chainId) return this.chainId;
-
+  protected assertChainId(): asserts this is this & { chainId: number } {
+    if (this.chainId) return;
     throw new CofhesdkError({
       code: CofhesdkErrorCode.ChainIdUninitialized,
       message: 'Chain ID is not set',
@@ -60,13 +70,11 @@ export abstract class BaseBuilder {
   }
 
   /**
-   * Gets the account address from the instance or fetches it from the wallet client
-   * @returns The account address
-   * @throws {CofhesdkError} If account is not set and walletClient is not available
+   * Asserts that this.account is populated
+   * @throws {CofhesdkError} If account is not set
    */
-  protected async getAccountOrThrow(): Promise<string> {
-    if (this.account) return this.account;
-
+  protected assertAccount(): asserts this is this & { account: string } {
+    if (this.account) return;
     throw new CofhesdkError({
       code: CofhesdkErrorCode.AccountUninitialized,
       message: 'Account is not set',
@@ -78,29 +86,11 @@ export abstract class BaseBuilder {
   }
 
   /**
-   * Gets the config or throws an error if not available
-   * @returns The config
-   * @throws {CofhesdkError} If config is not set
-   */
-  protected getConfigOrThrow(): CofhesdkConfig {
-    if (this.config) return this.config;
-    throw new CofhesdkError({
-      code: CofhesdkErrorCode.MissingConfig,
-      message: 'Builder config is undefined',
-      hint: 'Ensure client has been created with a config.',
-      context: {
-        config: this.config,
-      },
-    });
-  }
-
-  /**
-   * Gets the public client or throws an error if not available
-   * @returns The public client
+   * Asserts that this.publicClient is populated
    * @throws {CofhesdkError} If publicClient is not set
    */
-  protected getPublicClientOrThrow(): PublicClient {
-    if (this.publicClient) return this.publicClient;
+  protected assertPublicClient(): asserts this is this & { publicClient: PublicClient } {
+    if (this.publicClient) return;
     throw new CofhesdkError({
       code: CofhesdkErrorCode.MissingPublicClient,
       message: 'Public client not found',
@@ -112,12 +102,11 @@ export abstract class BaseBuilder {
   }
 
   /**
-   * Gets the wallet client or throws an error if not available
-   * @returns The wallet client
+   * Asserts that this.walletClient is populated
    * @throws {CofhesdkError} If walletClient is not set
    */
-  protected getWalletClientOrThrow(): WalletClient {
-    if (this.walletClient) return this.walletClient;
+  protected assertWalletClient(): asserts this is this & { walletClient: WalletClient } {
+    if (this.walletClient) return;
     throw new CofhesdkError({
       code: CofhesdkErrorCode.MissingWalletClient,
       message: 'Wallet client not found',
@@ -127,12 +116,4 @@ export abstract class BaseBuilder {
       },
     });
   }
-
-  /**
-   * Requires the client to be connected
-   * @throws {CofhesdkError} If client is not connected
-   */
-  protected requireConnectedOrThrow(): void {
-    if (this.requireConnected) this.requireConnected();
-  }
 }