@cofhe/sdk 0.0.0-alpha-20260409113701

package/CHANGELOG.md

@@ -0,0 +1,146 @@
+# @cofhe/sdk Changelog
+
+## 0.0.0-alpha-20260409113701
+
+### Minor Changes
+
+- 788a6e2: Add `onPoll` callback support for decrypt polling (tx + view) so consumers can observe poll progress.
+
+  - SDK decrypt helpers accept `onPoll` and emit `{ operation, requestId, attemptIndex, elapsedMs, intervalMs, timeoutMs }` once per poll attempt.
+  - React wiring supports passing the callback end-to-end.
+  - Docs updated with usage examples.
+
+- 9a06012: Tighten permit validation and treat invalid permits as missing.
+
+  - SDK: `PermitUtils.validate` now enforces schema + signed + not-expired (use `PermitUtils.validateSchema` for schema-only validation).
+  - SDK: `ValidationResult.error` is now a typed union (`'invalid-schema' | 'expired' | 'not-signed' | null`).
+  - React: rename `disabledDueToMissingPermit` to `disabledDueToMissingValidPermit` in read/decrypt hooks and token balance helpers, and disable reads when the active permit is invalid.
+
+### Patch Changes
+
+- 503536a: Improve logging ergonomics across React + web SDK.
+
+  - Add a configurable internal logger to `@cofhe/react` via `createCofheConfig({ react: { logger } })`.
+  - Make `@cofhe/sdk` `createWebStorage` logging opt-in via `createWebStorage({ enableLog })`.
+
+## 0.4.0
+
+### Patch Changes
+
+- e446642: Switch `decryptForTx` to Threshold Network v2 decrypt (submit + poll)
+
+## 0.3.2
+
+### Patch Changes
+
+- d4e86ea: Aligns with CTA encrypted variables bytes32 representation.
+
+  - **@cofhe/hardhat-plugin**: `hre.cofhe.mocks.getTestBed()`, `getMockTaskManager()`, `getMockACL()`, `getMockThresholdNetwork()`, and `getMockZkVerifier()` now return typed contracts (typechain interfaces) instead of untyped `Contract`. `getPlaintext(ctHash)` and `expectPlaintext(ctHash, value)` now accept bytes32 ctHashes as `string` support cofhe-contracts 0.1.0 CTA changes.
+  - **@cofhe/mock-contracts**: Export typechain-generated contract types (`TestBed`, `MockACL`, `MockTaskManager`, `MockZkVerifier`, `MockThresholdNetwork`) for use with the hardhat plugin. Typechain is run from artifact ABIs only; factory files are not generated.
+  - **@cofhe/abi**: CTA-related types use `bytes32` (string) instead of `uint256`. Decryption and return-type helpers aligned with cofhe-contracts 0.1.0.
+  - **@cofhe/sdk**: Decryption APIs (`decryptForTx`, `decryptForView`, and related builders) now also accept `string` for ciphertext hashes (bytes32) as well as `bigint`.
+
+- 0feaf3f: `cofheClient.decryptForTx` returns a ready-to-use signature
+
+## 0.3.1
+
+### Patch Changes
+
+- 370f0c7: no-op
+
+## 0.3.0
+
+### Minor Changes
+
+- 35024b6: Remove `sdk` from function names and exported types. Rename:
+
+  - `createCofhesdkConfig` -> `createCofheConfig`
+  - `createCofhesdkClient` -> `createCofheClient`
+  - `hre.cofhesdk.*` -> `hre.cofhe.*`
+  - `hre.cofhesdk.createCofheConfig()` → `hre.cofhe.createConfig()`
+  - `hre.cofhesdk.createCofheClient()` → `hre.cofhe.createClient()`
+  - `hre.cofhesdk.createBatteriesIncludedCofheClient()` → `hre.cofhe.createClientWithBatteries()`
+
+- 29c2401: implement decrypt-with-proof flows and related tests:
+
+  - Implement production `decryptForTx` backed by Threshold Network `POST /decrypt`, with explicit permit vs global-allowance selection.
+  - Rename mocks “Query Decrypter” -> “Threshold Network” and update SDK constants/contracts/artifacts accordingly.
+  - Extend mock contracts + hardhat plugin to publish & verify decryption results on-chain, and add end-to-end integration tests.
+
+- 650ea48: Align builder patterns in cofhe client api (`client.encryptInputs(..).encrypt()` and `client.decryptHandles(..).decrypt()`) to use the same terminator function `.execute()` instead of `.encrypt()`/`.decrypt()`.
+
+  Rename `setStepCallback` of encryptInputs builder to `onStep` to improve ergonomics.
+
+### Patch Changes
+
+- 5467d77: Adds `config.mocks.encryptDelay: number | [number, number, number, number, number]` to allow configurable mock encryption delay. Defaults to 0 delay on hardhat to keep tests quick.
+- 73b1502: Add `cofheClient.connection` getter which exposes inner connection state without using `getSnapshot()` reactive utility.
+
+## 0.2.1
+
+### Patch Changes
+
+- 409bfdf: Add `hash` field to permits, calculated at permit creation time. Replaces `PermitUtils.getHash(permit)` with `permit.hash`.
+- ac47e2f: Add `PermitUtils.checkValidityOnChain` to validate permits against the on-chain deployed ACL (source of truth).
+- 8af1b70: Updated to Zod 4 for improved performance and type safety. Includes internal changes to validation schemas and error handling that should not affect external API usage.
+
+## 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);
+      }
+    }, 20000);
+  });
+});

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