Skip to content

feat: migrate from @zama-fhe/relayer-sdk to @fhevm/sdk#275

Draft
ghermet wants to merge 7 commits intoprereleasefrom
feat/fhevm-sdk-migration-v2
Draft

feat: migrate from @zama-fhe/relayer-sdk to @fhevm/sdk#275
ghermet wants to merge 7 commits intoprereleasefrom
feat/fhevm-sdk-migration-v2

Conversation

@ghermet
Copy link
Copy Markdown
Contributor

@ghermet ghermet commented Apr 21, 2026

Summary

  • Replace CDN-loaded @zama-fhe/relayer-sdk with build-time @fhevm/sdk@1.0.0-alpha.1
  • Rewrite web and node workers to use FhevmClient action-based API (encryptValues, decryptValues, readPublicValuesWithSignatures, etc.)
  • Store StoredEIP712 alongside credentials for permit reconstruction via parseSignedDecryptionPermit
  • Widen ClearValueType to number | bigint | boolean | \0x${string}`` to match SDK's branded uint8/16/32 types
  • Remove all unnecessary type casts — SDK branded types (BytesHex, Bytes32Hex) are subtypes of viem's Hex/string
  • Use dynamic imports for @fhevm/sdk in node worker (matching existing pattern)
  • Raise size-limit thresholds (ESM 6 MB, CJS 2 MB) for bundled WASM binaries
  • Regenerate API reports for updated public surface
  • Fix cleartext test fixtures (eip712 field, bigint EIP-712 expectations)

Test plan

  • Unit tests pass (pnpm test:coverage — 1521 passed)
  • Typecheck passes across all workspace projects
  • Build succeeds (pnpm build)
  • Size-limit check passes
  • API reports regenerated and committed
  • E2E Playwright tests pass against local devnet
  • Verify decrypt flow works end-to-end with new @fhevm/sdk types

🤖 Generated with Claude Code

@cla-bot cla-bot Bot added the cla-signed label Apr 21, 2026
@ghermet ghermet changed the base branch from main to prerelease April 21, 2026 07:12
@ghermet ghermet force-pushed the feat/fhevm-sdk-migration-v2 branch from 143f44e to c3e383e Compare April 21, 2026 08:13
@github-actions
Copy link
Copy Markdown

github-actions Bot commented Apr 21, 2026

Coverage Report

Status Category Percentage Covered / Total
🔵 Lines 92.45% (🎯 80%) 2857 / 3090
🔵 Statements 92.52% 2935 / 3172
🔵 Functions 92.16% (🎯 80%) 906 / 983
🔵 Branches 85.12% (🎯 80%) 1110 / 1304
File Coverage
File Stmts Branches Functions Lines Uncovered Lines
Changed Files
packages/react-sdk/src/relayer/use-create-delegated-user-decrypt-eip712.ts 100% 100% 100% 100%
packages/react-sdk/src/relayer/use-request-zk-proof-verification.ts 100% 100% 100% 100%
packages/react-sdk/src/wagmi/wagmi-signer.ts 40% 51.85% 30.76% 40% 47-104
packages/sdk/src/zama-sdk.ts 96.96% 90.47% 100% 96.92% 208, 258, 490-491
packages/sdk/src/credentials/credential-validation.ts 100% 100% 100% 100%
packages/sdk/src/credentials/credentials-manager.ts 89.83% 55% 95% 89.83% 30-34, 64-68, 152
packages/sdk/src/credentials/delegated-credentials-manager.ts 96.22% 100% 89.47% 96.22% 85, 231
packages/sdk/src/query/create-delegated-user-decrypt-eip712.ts 100% 100% 100% 100%
packages/sdk/src/query/create-eip712.ts 100% 100% 100% 100%
packages/sdk/src/query/generate-keypair.ts 100% 100% 100% 100%
packages/sdk/src/query/request-zk-proof-verification.ts 100% 100% 100% 100%
packages/sdk/src/query/user-decrypt.ts 100% 100% 100% 100%
packages/sdk/src/relayer/relayer-node.ts 89.79% 76.47% 96.29% 89.69% 76, 125-128, 154-155, 278-287
packages/sdk/src/relayer/relayer-utils.ts 95.45% 100% 100% 95% 25
packages/sdk/src/relayer/relayer-web.ts 90.9% 72.72% 96.87% 90.83% 97, 101-103, 125, 184-187, 226-227, 414-423
packages/sdk/src/relayer/cleartext/eip712.ts 100% 100% 100% 100%
packages/sdk/src/relayer/cleartext/relayer-cleartext.ts 97.36% 91.66% 97.14% 97.19% 117, 163, 373
packages/sdk/src/token/readonly-token.ts 96.4% 83.82% 97.22% 96.25% 220, 358-360, 370, 377, 390, 680-682
packages/sdk/src/types/credentials.ts 100% 100% 100% 100%
packages/sdk/src/viem/viem-signer.ts 92% 83.33% 92.3% 95.83% 135
packages/sdk/src/worker/worker.base-client.ts 100% 100% 100% 100%
packages/sdk/src/worker/worker.client.ts 95% 50% 100% 94.44% 38
packages/sdk/src/worker/worker.node-client.ts 100% 100% 100% 100%
packages/sdk/src/worker/worker.node-pool.ts 100% 90% 100% 100%
Generated in workflow #1807 for commit 823746e by the Vitest Coverage Report Action

ghermet and others added 3 commits April 21, 2026 09:17
…ha.1

Replace the CDN-loaded @zama-fhe/relayer-sdk with @fhevm/sdk as a build-time
dependency. Workers now use FhevmClient (action-based API) instead of
FhevmInstance (method-based). EIP-712 typed data is stored alongside
credentials and passed through the full decrypt pipeline for permit parsing.

Key changes:
- Rewrite web and node workers for @fhevm/sdk client API
- Add StoredEIP712 type to credentials for permit reconstruction
- Define relayer types locally instead of importing from @zama-fhe/relayer-sdk
- Use @fhevm/sdk return types for EIP-712 response data
- Pass eip712 through decrypt pipeline (credentials → token → relayer → worker)

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
- Widen ClearValueType to include `number` for SDK's branded uint8/16/32
- Remove all `as unknown as Hex/string` casts (SDK branded types are subtypes)
- Remove redundant `client as FhevmClientInstance` casts after assertClient
- Type decrypt result mappings directly as response types
- Add missing `eip712` field to cleartext test fixtures
- Fix EIP-712 test expectations from string to bigint
- Regenerate API reports for updated public surface

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
Move @fhevm/sdk/actions/chain imports to dynamic `await import()` in
handleCreateEIP712 and handleCreateDelegatedEIP712, matching the existing
pattern for @fhevm/sdk/ethers in handleNodeInit. Update API reports.

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
@ghermet ghermet force-pushed the feat/fhevm-sdk-migration-v2 branch from 2201cee to 41df7a9 Compare April 21, 2026 08:17
ghermet and others added 3 commits April 21, 2026 09:21
The migration from CDN-loaded @zama-fhe/relayer-sdk to build-time
@fhevm/sdk bundles WASM binaries (~7.2 MB) inline. Raise limits to
match the new architecture: ESM 6 MB, CJS 2 MB.

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
Escape package names in JSDoc comments so api-extractor does not
misinterpret them as TSDoc block tags. Regenerate API reports.

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
@github-actions
Copy link
Copy Markdown

Public API Changes

Expand to see full diff
diff -ru a/react-sdk.api.md b/react-sdk.api.md
--- a/react-sdk.api.md	2026-04-21 09:34:04.620119896 +0000
+++ b/react-sdk.api.md	2026-04-21 09:34:04.653152448 +0000
@@ -5,9 +5,9 @@
 ```ts
 
 import * as _$_tanstack_react_query0 from '@tanstack/react-query';
-import * as _$_zama_fhe_relayer_sdk_web0 from '@zama-fhe/relayer-sdk/web';
 import * as _$_zama_fhe_sdk0 from '@zama-fhe/sdk';
 import * as _$react_jsx_runtime0 from 'react/jsx-runtime';
+import * as _$viem from 'viem';
 import { Address } from '@zama-fhe/sdk';
 import { ApproveUnderlyingParams } from '@zama-fhe/sdk/query';
 import { BatchBalancesResult } from '@zama-fhe/sdk';
@@ -25,12 +25,15 @@
 import { DelegationStatusData } from '@zama-fhe/sdk/query';
 import { EIP712TypedData } from '@zama-fhe/sdk';
 import { EncryptParams } from '@zama-fhe/sdk';
+import { EncryptResult } from '@zama-fhe/sdk';
 import { FinalizeUnwrapParams } from '@zama-fhe/sdk/query';
 import { GenericSigner } from '@zama-fhe/sdk';
 import { GenericStorage } from '@zama-fhe/sdk';
 import { PaginatedResult } from '@zama-fhe/sdk';
 import { PropsWithChildren } from 'react';
+import { PublicDecryptResult } from '@zama-fhe/sdk';
 import { PublicKeyData } from '@zama-fhe/sdk';
+import { PublicParamsData } from '@zama-fhe/sdk';
 import { ReadonlyToken } from '@zama-fhe/sdk';
 import { RelayerSDK } from '@zama-fhe/sdk';
 import { ResumeUnshieldParams } from '@zama-fhe/sdk/query';
@@ -49,7 +52,6 @@
 import { UserDecryptQueryConfig } from '@zama-fhe/sdk/query';
 import { ZamaSDK } from '@zama-fhe/sdk';
 import { ZamaSDKEventListener } from '@zama-fhe/sdk';
-import { ZKProofLike } from '@zama-fhe/sdk';
 
 // @public
 export function useAllow(options?: UseMutationOptions<void, Error, Address[]>): _$_tanstack_react_query0.UseMutationResult<void, Error, `0x${string}`[], unknown>;
@@ -125,12 +127,7 @@
 export function useConfidentialTransferFrom(config: UseZamaConfig, options?: UseMutationOptions<TransactionResult, Error, ConfidentialTransferFromParams, Address>): _$_tanstack_react_query0.UseMutationResult<TransactionResult, Error, ConfidentialTransferFromParams, `0x${string}`>;
 
 // @public
-export function useCreateDelegatedUserDecryptEIP712(): _$_tanstack_react_query0.UseMutationResult<Readonly<{
-    types: _$_zama_fhe_relayer_sdk_web0.KmsDelegatedUserDecryptEIP712TypesType;
-    primaryType: "DelegatedUserDecryptRequestVerification";
-    domain: _$_zama_fhe_relayer_sdk_web0.KmsEIP712DomainType;
-    message: _$_zama_fhe_relayer_sdk_web0.KmsDelegatedUserDecryptEIP712MessageType;
-}>, Error, CreateDelegatedUserDecryptEIP712Params, unknown>;
+export function useCreateDelegatedUserDecryptEIP712(): _$_tanstack_react_query0.UseMutationResult<EIP712TypedData, Error, CreateDelegatedUserDecryptEIP712Params, unknown>;
 
 // @public
 export function useCreateEIP712(): _$_tanstack_react_query0.UseMutationResult<EIP712TypedData, Error, CreateEIP712Params, unknown>;
@@ -155,16 +152,16 @@
 }
 
 // @public
-export function useEncrypt(): _$_tanstack_react_query0.UseMutationResult<Readonly<{
-    handles: Uint8Array[];
-    inputProof: Uint8Array;
-}>, Error, EncryptParams, unknown>;
+export function useEncrypt(): _$_tanstack_react_query0.UseMutationResult<EncryptResult, Error, EncryptParams, unknown>;
 
 // @public
 export function useFinalizeUnwrap(config: UseZamaConfig, options?: UseMutationOptions<TransactionResult, Error, FinalizeUnwrapParams, Address>): _$_tanstack_react_query0.UseMutationResult<TransactionResult, Error, FinalizeUnwrapParams, `0x${string}`>;
 
 // @public
-export function useGenerateKeypair(): _$_tanstack_react_query0.UseMutationResult<_$_zama_fhe_sdk0.KeypairType<`0x${string}`>, Error, void, unknown>;
+export function useGenerateKeypair(): _$_tanstack_react_query0.UseMutationResult<{
+    publicKey: _$viem.Hex;
+    privateKey: _$viem.Hex;
+}, Error, void, unknown>;
 
 // @public
 export function useIsAllowed(config: UseIsAllowedConfig): _$_tanstack_react_query0.UseQueryResult<boolean, Error>;
@@ -205,29 +202,19 @@
 export function useMetadataSuspense(tokenAddress: Address): _$_tanstack_react_query0.UseSuspenseQueryResult<TokenMetadata, Error>;
 
 // @public
-export function usePublicDecrypt(): _$_tanstack_react_query0.UseMutationResult<Readonly<{
-    clearValues: _$_zama_fhe_relayer_sdk_web0.ClearValues;
-    abiEncodedClearValues: `0x${string}`;
-    decryptionProof: `0x${string}`;
-}>, Error, `0x${string}`[], unknown>;
+export function usePublicDecrypt(): _$_tanstack_react_query0.UseMutationResult<PublicDecryptResult, Error, `0x${string}`[], unknown>;
 
 // @public
 export function usePublicKey(): _$_tanstack_react_query0.UseQueryResult<PublicKeyData | null, Error>;
 
 // @public
-export function usePublicParams(bits: number): _$_tanstack_react_query0.UseQueryResult<{
-    publicParams: Uint8Array<ArrayBufferLike>;
-    publicParamsId: string;
-} | null, Error>;
+export function usePublicParams(bits: number): _$_tanstack_react_query0.UseQueryResult<PublicParamsData | null, Error>;
 
 // @public
 export function useReadonlyToken(address: Address): _$_zama_fhe_sdk0.ReadonlyToken;
 
 // @public
-export function useRequestZKProofVerification(): _$_tanstack_react_query0.UseMutationResult<Readonly<{
-    handles: Uint8Array[];
-    inputProof: Uint8Array;
-}>, Error, ZKProofLike, unknown>;
+export function useRequestZKProofVerification(): _$_tanstack_react_query0.UseMutationResult<EncryptResult, Error, unknown, unknown>;
 
 // @public
 export function useResumeUnshield(config: UseZamaConfig, options?: UseMutationOptions<TransactionResult, Error, ResumeUnshieldParams, Address>): _$_tanstack_react_query0.UseMutationResult<TransactionResult, Error, ResumeUnshieldParams, `0x${string}`>;
@@ -305,7 +292,7 @@
 export function useUnwrapAll(config: UseZamaConfig, options?: UseMutationOptions<TransactionResult, Error, void, Address>): _$_tanstack_react_query0.UseMutationResult<TransactionResult, Error, void, `0x${string}`>;
 
 // @public
-export function useUserDecrypt(config: UserDecryptQueryConfig, options?: Omit<UseQueryOptions<DecryptResult>, "queryKey" | "queryFn">): _$_tanstack_react_query0.UseQueryResult<Readonly<Record<`0x${string}`, _$_zama_fhe_sdk0.ClearValueType>>, Error>;
+export function useUserDecrypt(config: UserDecryptQueryConfig, options?: Omit<UseQueryOptions<DecryptResult>, "queryKey" | "queryFn">): _$_tanstack_react_query0.UseQueryResult<DecryptResult, Error>;
 
 // @public
 export type UseUserDecryptResult = ReturnType<typeof useUserDecrypt>;
diff -ru a/sdk-ethers.api.md b/sdk-ethers.api.md
--- a/sdk-ethers.api.md	2026-04-21 09:34:04.623119874 +0000
+++ b/sdk-ethers.api.md	2026-04-21 09:34:04.652119667 +0000
@@ -6,7 +6,6 @@
 
 import { Abi } from 'viem';
 import { Address } from 'viem';
-import { Bytes32Hex } from '@zama-fhe/relayer-sdk/bundle';
 import { ContractFunctionArgs } from 'viem';
 import { ContractFunctionName } from 'viem';
 import { ContractFunctionReturnType } from 'viem';
@@ -15,8 +14,6 @@
 import { EIP1193Provider } from 'viem';
 import { ethers } from 'ethers';
 import { Hex } from 'viem';
-import { KmsDelegatedUserDecryptEIP712Type } from '@zama-fhe/relayer-sdk/bundle';
-import { KmsUserDecryptEIP712Type } from '@zama-fhe/relayer-sdk/bundle';
 import { ProviderConnectInfo } from 'viem';
 import { ProviderMessage } from 'viem';
 import { ProviderRpcError } from 'viem';
diff -ru a/sdk-node.api.md b/sdk-node.api.md
--- a/sdk-node.api.md	2026-04-21 09:34:04.627119846 +0000
+++ b/sdk-node.api.md	2026-04-21 09:34:04.652730255 +0000
@@ -5,23 +5,8 @@
 ```ts
 
 import { Address } from 'viem';
-import { Bytes32Hex } from '@zama-fhe/relayer-sdk/bundle';
-import { ClearValueType } from '@zama-fhe/relayer-sdk/bundle';
-import { FhevmInstanceConfig } from '@zama-fhe/relayer-sdk/bundle';
-import { FhevmInstanceConfig as FhevmInstanceConfig_2 } from '@zama-fhe/relayer-sdk/node';
 import { Hex } from 'viem';
-import { InputProofBytesType } from '@zama-fhe/relayer-sdk/bundle';
-import { InputProofBytesType as InputProofBytesType_2 } from '@zama-fhe/relayer-sdk/node';
-import { KeypairType } from '@zama-fhe/relayer-sdk/bundle';
-import { KeypairType as KeypairType_2 } from '@zama-fhe/relayer-sdk/node';
-import { KmsDelegatedUserDecryptEIP712Type } from '@zama-fhe/relayer-sdk/bundle';
-import { KmsDelegatedUserDecryptEIP712Type as KmsDelegatedUserDecryptEIP712Type_2 } from '@zama-fhe/relayer-sdk/node';
-import { KmsUserDecryptEIP712Type } from '@zama-fhe/relayer-sdk/bundle';
-import { PublicDecryptResults } from '@zama-fhe/relayer-sdk/bundle';
-import * as SDK from '@zama-fhe/relayer-sdk/bundle';
 import { Worker as Worker_2 } from 'node:worker_threads';
-import { ZKProofLike } from '@zama-fhe/relayer-sdk/bundle';
-import { ZKProofLike as ZKProofLike_2 } from '@zama-fhe/relayer-sdk/node';
 
 // Warning: (ae-forgotten-export) The symbol "GenericStorage" needs to be exported by the entry point index.d.ts
 //
@@ -89,7 +74,7 @@
     // (undocumented)
     publicDecrypt(handles: Handle[]): Promise<PublicDecryptResponseData>;
     // (undocumented)
-    requestZKProofVerification(zkProof: ZKProofLike): Promise<RequestZKProofVerificationResponseData>;
+    requestZKProofVerification(zkProof: unknown): Promise<RequestZKProofVerificationResponseData>;
     // (undocumented)
     protected sendRequest<T>(type: WorkerRequestType, payload: WorkerRequest["payload"], timeoutMs?: number): Promise<T>;
     // (undocumented)
@@ -102,7 +87,8 @@
     protected abstract wireEvents(worker: TWorker): void;
 }
 
-export { ClearValueType }
+// @public
+export type ClearValueType = number | bigint | boolean | `0x${string}`;
 
 // @public (undocumented)
 export type CreateDelegatedEIP712Payload = CreateDelegatedEIP712Request["payload"];
@@ -121,8 +107,10 @@
     type: "CREATE_DELEGATED_EIP712";
 }
 
+// Warning: (ae-forgotten-export) The symbol "KmsDelegatedUserDecryptEip712" needs to be exported by the entry point index.d.ts
+//
 // @public (undocumented)
-export type CreateDelegatedEIP712ResponseData = KmsDelegatedUserDecryptEIP712Type;
+export type CreateDelegatedEIP712ResponseData = KmsDelegatedUserDecryptEip712;
 
 // @public (undocumented)
 export type CreateEIP712Payload = CreateEIP712Request["payload"];
@@ -140,8 +128,10 @@
     type: "CREATE_EIP712";
 }
 
+// Warning: (ae-forgotten-export) The symbol "KmsUserDecryptEip712" needs to be exported by the entry point index.d.ts
+//
 // @public (undocumented)
-export type CreateEIP712ResponseData = KmsUserDecryptEIP712Type;
+export type CreateEIP712ResponseData = KmsUserDecryptEip712;
 
 // @public
 export interface DelegatedUserDecryptParams {
@@ -153,6 +143,10 @@
     delegatorAddress: Address;
     // (undocumented)
     durationDays: number;
+    // Warning: (ae-forgotten-export) The symbol "StoredEIP712" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    eip712: StoredEIP712;
     // (undocumented)
     handles: Handle[];
     // (undocumented)
@@ -184,6 +178,7 @@
         delegateAddress: Address;
         startTimestamp: number;
         durationDays: number;
+        eip712: StoredEIP712;
     };
     // (undocumented)
     type: "DELEGATED_USER_DECRYPT";
@@ -196,7 +191,20 @@
 }
 
 // @public
-export type EIP712TypedData = KmsUserDecryptEIP712Type | KmsDelegatedUserDecryptEIP712Type;
+export type EIP712TypedData = {
+    readonly domain: {
+        readonly name: string;
+        readonly version: string;
+        readonly chainId: bigint;
+        readonly verifyingContract: `0x${string}`;
+    };
+    readonly types: Record<string, readonly {
+        readonly name: string;
+        readonly type: string;
+    }[]>;
+    readonly primaryType: string;
+    readonly message: Record<string, unknown>;
+};
 
 // @public
 export interface EncryptParams {
@@ -224,10 +232,20 @@
 }
 
 // @public (undocumented)
-export type EncryptResponseData = InputProofBytesType;
+export interface EncryptResponseData {
+    // (undocumented)
+    handles: Uint8Array[];
+    // (undocumented)
+    inputProof: Uint8Array;
+}
 
 // @public
-export type EncryptResult = InputProofBytesType;
+export interface EncryptResult {
+    // (undocumented)
+    handles: Uint8Array[];
+    // (undocumented)
+    inputProof: Uint8Array;
+}
 
 // Warning: (ae-forgotten-export) The symbol "BaseResponse" needs to be exported by the entry point index.d.ts
 //
@@ -409,7 +427,7 @@
     // (undocumented)
     publicDecrypt(handles: Handle[]): Promise<PublicDecryptResponseData>;
     // (undocumented)
-    requestZKProofVerification(zkProof: ZKProofLike): Promise<RequestZKProofVerificationResponseData>;
+    requestZKProofVerification(zkProof: unknown): Promise<RequestZKProofVerificationResponseData>;
     // (undocumented)
     terminate(): void;
     // (undocumented)
@@ -437,20 +455,27 @@
     // (undocumented)
     abiEncodedClearValues: Hex;
     // (undocumented)
-    clearValues: Readonly<Record<Handle, ClearValueType>>;
+    clearValues: Record<Handle, ClearValueType>;
     // (undocumented)
     decryptionProof: Hex;
 }
 
 // @public
-export type PublicDecryptResult = PublicDecryptResults;
+export interface PublicDecryptResult {
+    // (undocumented)
+    abiEncodedClearValues: Hex;
+    // (undocumented)
+    clearValues: Readonly<Record<Handle, ClearValueType>>;
+    // (undocumented)
+    decryptionProof: Hex;
+}
 
 // @public
 export class RelayerNode implements RelayerSDK, Disposable {
     [Symbol.dispose](): void;
     constructor(config: RelayerNodeConfig);
     // (undocumented)
-    createDelegatedUserDecryptEIP712(publicKey: Hex, contractAddresses: Address[], delegatorAddress: Address, startTimestamp: number, durationDays?: number): Promise<KmsDelegatedUserDecryptEIP712Type_2>;
+    createDelegatedUserDecryptEIP712(publicKey: Hex, contractAddresses: Address[], delegatorAddress: Address, startTimestamp: number, durationDays?: number): Promise<EIP712TypedData>;
     // (undocumented)
     createEIP712(publicKey: Hex, contractAddresses: Address[], startTimestamp: number, durationDays?: number): Promise<EIP712TypedData>;
     // (undocumented)
@@ -458,7 +483,10 @@
     // (undocumented)
     encrypt(params: EncryptParams): Promise<EncryptResult>;
     // (undocumented)
-    generateKeypair(): Promise<KeypairType_2<Hex>>;
+    generateKeypair(): Promise<{
+        publicKey: Hex;
+        privateKey: Hex;
+    }>;
     // (undocumented)
     getAclAddress(): Promise<Address>;
     // Warning: (ae-forgotten-export) The symbol "PublicKeyData" needs to be exported by the entry point index.d.ts
@@ -472,7 +500,7 @@
     // (undocumented)
     publicDecrypt(handles: Handle[]): Promise<PublicDecryptResult>;
     // (undocumented)
-    requestZKProofVerification(zkProof: ZKProofLike_2): Promise<InputProofBytesType_2>;
+    requestZKProofVerification(zkProof: unknown): Promise<EncryptResult>;
     // (undocumented)
     terminate(): void;
     // (undocumented)
@@ -488,21 +516,24 @@
     // (undocumented)
     poolSize?: number;
     // (undocumented)
-    transports: Record<number, Partial<FhevmInstanceConfig_2>>;
+    transports: Record<number, Partial<FhevmInstanceConfig>>;
 }
 
 // @public
 export interface RelayerSDK {
-    createDelegatedUserDecryptEIP712(publicKey: Hex, contractAddresses: Address[], delegatorAddress: Address, startTimestamp: number, durationDays?: number): Promise<KmsDelegatedUserDecryptEIP712Type>;
+    createDelegatedUserDecryptEIP712(publicKey: Hex, contractAddresses: Address[], delegatorAddress: Address, startTimestamp: number, durationDays?: number): Promise<EIP712TypedData>;
     createEIP712(publicKey: Hex, contractAddresses: Address[], startTimestamp: number, durationDays?: number): Promise<EIP712TypedData>;
     delegatedUserDecrypt(params: DelegatedUserDecryptParams): Promise<Readonly<Record<Handle, ClearValueType>>>;
     encrypt(params: EncryptParams): Promise<EncryptResult>;
-    generateKeypair(): Promise<KeypairType<Hex>>;
+    generateKeypair(): Promise<{
+        publicKey: Hex;
+        privateKey: Hex;
+    }>;
     getAclAddress(): Promise<Address>;
     getPublicKey(): Promise<PublicKeyData | null>;
     getPublicParams(bits: number): Promise<PublicParamsData | null>;
     publicDecrypt(handles: Handle[]): Promise<PublicDecryptResult>;
-    requestZKProofVerification(zkProof: ZKProofLike): Promise<InputProofBytesType>;
+    requestZKProofVerification(zkProof: unknown): Promise<EncryptResult>;
     terminate(): void;
     userDecrypt(params: UserDecryptParams): Promise<Readonly<Record<Handle, ClearValueType>>>;
 }
@@ -511,14 +542,17 @@
 export interface RequestZKProofVerificationRequest extends BaseRequest {
     // (undocumented)
     payload: {
-        zkProof: ZKProofLike;
+        zkProof: unknown;
     };
     // (undocumented)
     type: "REQUEST_ZK_PROOF_VERIFICATION";
 }
 
 // @public (undocumented)
-export type RequestZKProofVerificationResponseData = InputProofBytesType;
+export interface RequestZKProofVerificationResponseData {
+    // (undocumented)
+    error: string;
+}
 
 // @public
 export const SepoliaConfig: {
@@ -559,6 +593,8 @@
     // (undocumented)
     durationDays: number;
     // (undocumented)
+    eip712: StoredEIP712;
+    // (undocumented)
     handles: Handle[];
     // (undocumented)
     privateKey: Hex;
@@ -590,6 +626,7 @@
         signerAddress: Address;
         startTimestamp: number;
         durationDays: number;
+        eip712: StoredEIP712;
     };
     // (undocumented)
     type: "USER_DECRYPT";
@@ -610,6 +647,10 @@
 // @public (undocumented)
 export type WorkerResponse<T> = SuccessResponse<T> | ErrorResponse;
 
+// Warnings were encountered during analysis:
+//
+// dist/esm/relayer-sdk.types-CBurl-AZ.d.ts:90:5 - (ae-forgotten-export) The symbol "FhevmInstanceConfig" needs to be exported by the entry point index.d.ts
+
 // (No @packageDocumentation comment for this package)
 

diff -ru a/sdk-query.api.md b/sdk-query.api.md
--- a/sdk-query.api.md 2026-04-21 09:34:04.630119824 +0000
+++ b/sdk-query.api.md 2026-04-21 09:34:04.652776863 +0000
@@ -6,25 +6,14 @@

import { Abi } from 'viem';
import { Address } from 'viem';
-import { Bytes32Hex } from '@zama-fhe/relayer-sdk/bundle';
-import { ClearValueType } from '@zama-fhe/relayer-sdk/bundle';
import { ContractFunctionArgs } from 'viem';
import { ContractFunctionName } from 'viem';
import { ContractFunctionReturnType } from 'viem';
import { Hex } from 'viem';
-import { InputProofBytesType } from '@zama-fhe/relayer-sdk/bundle';
-import { KeypairType } from '@zama-fhe/relayer-sdk/bundle';
-import { KmsDelegatedUserDecryptEIP712Type } from '@zama-fhe/relayer-sdk/bundle';
-import { KmsUserDecryptEIP712Type } from '@zama-fhe/relayer-sdk/bundle';
-import { KmsUserDecryptEIP712UserArgsType } from '@zama-fhe/relayer-sdk/bundle';
import { MutationFunctionContext } from '@tanstack/query-core';
-import { PublicDecryptResults } from '@zama-fhe/relayer-sdk/bundle';
import { QueryKey } from '@tanstack/query-core';
import { QueryObserverOptions } from '@tanstack/query-core';
-import * as SDK from '@zama-fhe/relayer-sdk/bundle';
import { skipToken } from '@tanstack/query-core';
-import { UserDecryptResults } from '@zama-fhe/relayer-sdk/bundle';
-import { ZKProofLike } from '@zama-fhe/relayer-sdk/bundle';

// @public (undocumented)
export function allowMutationOptions(sdk: ZamaSDK): MutationFactoryOptions<readonly ["zama.allow"], Address[], void>;
@@ -86,7 +75,8 @@
// @public
export type BatchDecryptBalancesAsParams = BatchDecryptAsOptions;

-export { ClearValueType }
+// @public
+export type ClearValueType = number | bigint | boolean | 0x${string};

// @public (undocumented)
export function confidentialApproveMutationOptions(token: Token): MutationFactoryOptions<readonly ["zama.confidentialApprove", Address], ConfidentialApproveParams, TransactionResult>;
@@ -180,7 +170,7 @@
}

// @public (undocumented)
-export function createDelegatedUserDecryptEIP712MutationOptions(sdk: ZamaSDK): MutationFactoryOptions<readonly ["zama.createDelegatedUserDecryptEIP712"], CreateDelegatedUserDecryptEIP712Params, KmsDelegatedUserDecryptEIP712Type>;
+export function createDelegatedUserDecryptEIP712MutationOptions(sdk: ZamaSDK): MutationFactoryOptions<readonly ["zama.createDelegatedUserDecryptEIP712"], CreateDelegatedUserDecryptEIP712Params, EIP712TypedData>;

// @public
export interface CreateDelegatedUserDecryptEIP712Params {
@@ -200,11 +190,16 @@
export function createEIP712MutationOptions(sdk: ZamaSDK): MutationFactoryOptions<readonly ["zama.createEIP712"], CreateEIP712Params, EIP712TypedData>;

// @public
-export type CreateEIP712Params = Pick<KmsUserDecryptEIP712UserArgsType, "startTimestamp"> & {

  • publicKey: Hex;
    +export interface CreateEIP712Params {
  • // (undocumented)
    contractAddresses: Address[];
  • // (undocumented)
    durationDays?: number;
    -};
  • // (undocumented)
  • publicKey: Hex;
  • // (undocumented)
  • startTimestamp: number;
    +}

// @public (undocumented)
export interface CredentialsAllowedEvent extends BaseEvent {
@@ -345,7 +340,7 @@
}

// @public
-export type DecryptResult = UserDecryptResults;
+export type DecryptResult = Record<Handle, ClearValueType>;

// @public (undocumented)
export interface DecryptStartEvent extends BaseEvent {
@@ -378,6 +373,10 @@
delegatorAddress: Address;
// (undocumented)
durationDays: number;

  • // Warning: (ae-forgotten-export) The symbol "StoredEIP712" needs to be exported by the entry point index.d.ts
  • //
  • // (undocumented)
  • eip712: StoredEIP712;
    // (undocumented)
    handles: Handle[];
    // (undocumented)
    @@ -427,7 +426,20 @@
    }

// @public
-export type EIP712TypedData = KmsUserDecryptEIP712Type | KmsDelegatedUserDecryptEIP712Type;
+export type EIP712TypedData = {

  • readonly domain: {
  •    readonly name: string;
    
  •    readonly version: string;
    
  •    readonly chainId: bigint;
    
  •    readonly verifyingContract: `0x${string}`;
    
  • };
  • readonly types: Record<string, readonly {
  •    readonly name: string;
    
  •    readonly type: string;
    
  • }[]>;
  • readonly primaryType: string;
  • readonly message: Record<string, unknown>;
    +};

// @public (undocumented)
export interface EncryptEndEvent extends BaseEvent {
@@ -452,7 +464,7 @@
type: "ebool";
} | {
value: bigint;

  • type: Exclude<SDK.FheTypeName, "ebool" | "eaddress">;
  • type: Exclude<FheTypeName, "ebool" | "eaddress">;
    } | {
    value: Address;
    type: "eaddress";
    @@ -471,7 +483,12 @@
    }

// @public
-export type EncryptResult = InputProofBytesType;
+export interface EncryptResult {

  • // (undocumented)
  • handles: Uint8Array[];
  • // (undocumented)
  • inputProof: Uint8Array;
    +}

// @public (undocumented)
export interface EncryptStartEvent extends BaseEvent {
@@ -500,7 +517,10 @@
}

// @public (undocumented)
-export function generateKeypairMutationOptions(sdk: ZamaSDK): MutationFactoryOptions<readonly ["zama.generateKeypair"], void, KeypairType>;
+export function generateKeypairMutationOptions(sdk: ZamaSDK): MutationFactoryOptions<readonly ["zama.generateKeypair"], void, {

  • publicKey: Hex;
  • privateKey: Hex;
    +}>;

// @public
export interface GenericSigner {
@@ -630,7 +650,14 @@
export function publicDecryptMutationOptions(sdk: ZamaSDK): MutationFactoryOptions<readonly ["zama.publicDecrypt"], Handle[], PublicDecryptResult>;

// @public
-export type PublicDecryptResult = PublicDecryptResults;
+export interface PublicDecryptResult {

  • // (undocumented)
  • abiEncodedClearValues: Hex;
  • // (undocumented)
  • clearValues: Readonly<Record<Handle, ClearValueType>>;
  • // (undocumented)
  • decryptionProof: Hex;
    +}

// @public (undocumented)
export interface PublicKeyQueryConfig {
@@ -732,22 +759,25 @@

// @public
export interface RelayerSDK {

  • createDelegatedUserDecryptEIP712(publicKey: Hex, contractAddresses: Address[], delegatorAddress: Address, startTimestamp: number, durationDays?: number): Promise;
  • createDelegatedUserDecryptEIP712(publicKey: Hex, contractAddresses: Address[], delegatorAddress: Address, startTimestamp: number, durationDays?: number): Promise;
    createEIP712(publicKey: Hex, contractAddresses: Address[], startTimestamp: number, durationDays?: number): Promise;
    delegatedUserDecrypt(params: DelegatedUserDecryptParams): Promise<Readonly<Record<Handle, ClearValueType>>>;
    encrypt(params: EncryptParams): Promise;
  • generateKeypair(): Promise<KeypairType>;
  • generateKeypair(): Promise<{
  •    publicKey: Hex;
    
  •    privateKey: Hex;
    
  • }>;
    getAclAddress(): Promise;
    getPublicKey(): Promise<PublicKeyData | null>;
    getPublicParams(bits: number): Promise<PublicParamsData | null>;
    publicDecrypt(handles: Handle[]): Promise;
  • requestZKProofVerification(zkProof: ZKProofLike): Promise;
  • requestZKProofVerification(zkProof: unknown): Promise;
    terminate(): void;
    userDecrypt(params: UserDecryptParams): Promise<Readonly<Record<Handle, ClearValueType>>>;
    }

// @public (undocumented)
-export function requestZKProofVerificationMutationOptions(sdk: ZamaSDK): MutationFactoryOptions<readonly ["zama.requestZKProofVerification"], ZKProofLike, InputProofBytesType>;
+export function requestZKProofVerificationMutationOptions(sdk: ZamaSDK): MutationFactoryOptions<readonly ["zama.requestZKProofVerification"], unknown, EncryptResult>;

// @public (undocumented)
export function resumeUnshieldMutationOptions(token: Token): MutationFactoryOptions<readonly ["zama.resumeUnshield", Address], ResumeUnshieldParams, TransactionResult>;
@@ -840,6 +870,7 @@
export interface StoredCredentials {
contractAddresses: Address[];
durationDays: number;

  • eip712: StoredEIP712;
    privateKey: Hex;
    publicKey: Hex;
    signature: Hex;
    @@ -1116,6 +1147,8 @@
    // (undocumented)
    durationDays: number;
    // (undocumented)
  • eip712: StoredEIP712;
  • // (undocumented)
    handles: Handle[];
    // (undocumented)
    privateKey: Hex;
    @@ -1436,6 +1469,10 @@
    readonly UnshieldPhase2Submitted: "unshield:phase2_submitted";
    };

+// Warnings were encountered during analysis:
+//
+// dist/esm/relayer-sdk.types-CBurl-AZ.d.ts:486:3 - (ae-forgotten-export) The symbol "FheTypeName" needs to be exported by the entry point index.d.ts
+
// (No @packageDocumentation comment for this package)

diff -ru a/sdk-viem.api.md b/sdk-viem.api.md
--- a/sdk-viem.api.md	2026-04-21 09:34:04.633119803 +0000
+++ b/sdk-viem.api.md	2026-04-21 09:34:04.652829491 +0000
@@ -6,14 +6,11 @@

import { Abi } from 'viem';
import { Address } from 'viem';
-import { Bytes32Hex } from '@zama-fhe/relayer-sdk/bundle';
import { ContractFunctionArgs } from 'viem';
import { ContractFunctionName } from 'viem';
import { ContractFunctionReturnType } from 'viem';
import { EIP1193Provider } from 'viem';
import { Hex } from 'viem';
-import { KmsDelegatedUserDecryptEIP712Type } from '@zama-fhe/relayer-sdk/bundle';
-import { KmsUserDecryptEIP712Type } from '@zama-fhe/relayer-sdk/bundle';
import { PublicClient } from 'viem';
import { WalletClient } from 'viem';

diff -ru a/sdk.api.md b/sdk.api.md
--- a/sdk.api.md	2026-04-21 09:34:04.638119767 +0000
+++ b/sdk.api.md	2026-04-21 09:34:04.652867066 +0000
@@ -6,22 +6,10 @@

import { Abi } from 'viem';
import { Address } from 'viem';
-import { Bytes32Hex } from '@zama-fhe/relayer-sdk/bundle';
-import { ClearValueType } from '@zama-fhe/relayer-sdk/bundle';
import { ContractFunctionArgs } from 'viem';
import { ContractFunctionName } from 'viem';
import { ContractFunctionReturnType } from 'viem';
-import { FheTypeName } from '@zama-fhe/relayer-sdk/bundle';
-import { FhevmInstanceConfig } from '@zama-fhe/relayer-sdk/bundle';
import { Hex } from 'viem';
-import { InputProofBytesType } from '@zama-fhe/relayer-sdk/bundle';
-import { KeypairType } from '@zama-fhe/relayer-sdk/bundle';
-import { KmsDelegatedUserDecryptEIP712Type } from '@zama-fhe/relayer-sdk/bundle';
-import { KmsUserDecryptEIP712Type } from '@zama-fhe/relayer-sdk/bundle';
-import { PublicDecryptResults } from '@zama-fhe/relayer-sdk/bundle';
-import * as SDK from '@zama-fhe/relayer-sdk/bundle';
-import { UserDecryptResults } from '@zama-fhe/relayer-sdk/bundle';
-import { ZKProofLike } from '@zama-fhe/relayer-sdk/bundle';

// @public
export const ACL_TOPICS: readonly [`0x${string}`, `0x${string}`];
@@ -544,7 +532,8 @@
// @public
export function clearPendingUnshield(storage: GenericStorage, wrapperAddress: Address): Promise<void>;

-export { ClearValueType }
+// @public
+export type ClearValueType = number | bigint | boolean | `0x${string}`;

// @public
export function confidentialBalanceOfContract(tokenAddress: Address, userAddress: Address): {
@@ -6164,7 +6153,7 @@
}

// @public
-export type DecryptResult = UserDecryptResults;
+export type DecryptResult = Record<Handle, ClearValueType>;

// @public (undocumented)
export interface DecryptStartEvent extends BaseEvent {
@@ -6234,6 +6223,10 @@
    delegatorAddress: Address;
    // (undocumented)
    durationDays: number;
+    // Warning: (ae-forgotten-export) The symbol "StoredEIP712" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    eip712: StoredEIP712;
    // (undocumented)
    handles: Handle[];
    // (undocumented)
@@ -6390,7 +6383,20 @@
}

// @public
-export type EIP712TypedData = KmsUserDecryptEIP712Type | KmsDelegatedUserDecryptEIP712Type;
+export type EIP712TypedData = {
+    readonly domain: {
+        readonly name: string;
+        readonly version: string;
+        readonly chainId: bigint;
+        readonly verifyingContract: `0x${string}`;
+    };
+    readonly types: Record<string, readonly {
+        readonly name: string;
+        readonly type: string;
+    }[]>;
+    readonly primaryType: string;
+    readonly message: Record<string, unknown>;
+};

// @public (undocumented)
export interface EncryptEndEvent extends BaseEvent {
@@ -6415,7 +6421,7 @@
    type: "ebool";
} | {
    value: bigint;
-    type: Exclude<SDK.FheTypeName, "ebool" | "eaddress">;
+    type: Exclude<FheTypeName, "ebool" | "eaddress">;
} | {
    value: Address;
    type: "eaddress";
@@ -6436,7 +6442,12 @@
}

// @public
-export type EncryptResult = InputProofBytesType;
+export interface EncryptResult {
+    // (undocumented)
+    handles: Uint8Array[];
+    // (undocumented)
+    inputProof: Uint8Array;
+}

// @public (undocumented)
export interface EncryptStartEvent extends BaseEvent {
@@ -6458,9 +6469,36 @@
// @public
export const ERC7984_WRAPPER_INTERFACE_ID_LEGACY: "0xd04584ba";

-export { FheTypeName }
+// @public
+export type FheTypeName = "ebool" | "euint8" | "euint16" | "euint32" | "euint64" | "euint128" | "euint256" | "eaddress";

-export { FhevmInstanceConfig }
+// @public
+export interface FhevmInstanceConfig {
+    // (undocumented)
+    [key: string]: unknown;
+    // (undocumented)
+    aclContractAddress: string;
+    // (undocumented)
+    batchRpcCalls?: boolean;
+    // (undocumented)
+    chainId: number;
+    // (undocumented)
+    gatewayChainId: number;
+    // (undocumented)
+    inputVerifierContractAddress?: string;
+    // (undocumented)
+    kmsContractAddress: string;
+    // (undocumented)
+    network?: string;
+    // (undocumented)
+    networkUrl?: string;
+    // (undocumented)
+    relayerUrl: string;
+    // (undocumented)
+    verifyingContractAddressDecryption: string;
+    // (undocumented)
+    verifyingContractAddressInputVerification?: string;
+}

// @public
export function finalizeUnwrapContract(wrapper: Address, unwrapRequestId: Handle, burntAmountCleartext: bigint, decryptionProof: Hex): {
@@ -8692,7 +8730,7 @@
};

// @public
-export type Handle = Bytes32Hex;
+export type Handle = `0x${string}`;

// @public
export const HardhatConfig: {
@@ -9718,8 +9756,6 @@
    readonly args: readonly [];
};

-export { InputProofBytesType }
-
// @public
export class InsufficientConfidentialBalanceError extends ZamaError {
    constructor(message: string, details: BalanceErrorDetails, options?: ErrorOptions);
@@ -11385,10 +11421,6 @@
    constructor(message: string, options?: ErrorOptions);
}

-export { KeypairType }
-
-export { KmsDelegatedUserDecryptEIP712Type }
-
// @public
export interface ListPairsOptions {
    metadata?: boolean;
@@ -11600,7 +11632,14 @@
}

// @public
-export type PublicDecryptResult = PublicDecryptResults;
+export interface PublicDecryptResult {
+    // (undocumented)
+    abiEncodedClearValues: Hex;
+    // (undocumented)
+    clearValues: Readonly<Record<Handle, ClearValueType>>;
+    // (undocumented)
+    decryptionProof: Hex;
+}

// @public
export interface PublicKeyData {
@@ -11611,7 +11650,12 @@
}

// @public
-export type PublicParamsData = SDK.PublicParams<Uint8Array>[keyof SDK.PublicParams<Uint8Array>];
+export interface PublicParamsData {
+    // (undocumented)
+    publicParams: Uint8Array;
+    // (undocumented)
+    publicParamsId: string;
+}

// @public
export function rateContract(tokenAddress: Address): {
@@ -13006,16 +13050,19 @@

// @public
export interface RelayerSDK {
-    createDelegatedUserDecryptEIP712(publicKey: Hex, contractAddresses: Address[], delegatorAddress: Address, startTimestamp: number, durationDays?: number): Promise<KmsDelegatedUserDecryptEIP712Type>;
+    createDelegatedUserDecryptEIP712(publicKey: Hex, contractAddresses: Address[], delegatorAddress: Address, startTimestamp: number, durationDays?: number): Promise<EIP712TypedData>;
    createEIP712(publicKey: Hex, contractAddresses: Address[], startTimestamp: number, durationDays?: number): Promise<EIP712TypedData>;
    delegatedUserDecrypt(params: DelegatedUserDecryptParams): Promise<Readonly<Record<Handle, ClearValueType>>>;
    encrypt(params: EncryptParams): Promise<EncryptResult>;
-    generateKeypair(): Promise<KeypairType<Hex>>;
+    generateKeypair(): Promise<{
+        publicKey: Hex;
+        privateKey: Hex;
+    }>;
    getAclAddress(): Promise<Address>;
    getPublicKey(): Promise<PublicKeyData | null>;
    getPublicParams(bits: number): Promise<PublicParamsData | null>;
    publicDecrypt(handles: Handle[]): Promise<PublicDecryptResult>;
-    requestZKProofVerification(zkProof: ZKProofLike): Promise<InputProofBytesType>;
+    requestZKProofVerification(zkProof: unknown): Promise<EncryptResult>;
    terminate(): void;
    userDecrypt(params: UserDecryptParams): Promise<Readonly<Record<Handle, ClearValueType>>>;
}
@@ -13027,18 +13074,21 @@
export class RelayerWeb implements RelayerSDK, Disposable {
    [Symbol.dispose](): void;
    constructor(config: RelayerWebConfig);
-    createDelegatedUserDecryptEIP712(publicKey: Hex, contractAddresses: Address[], delegatorAddress: Address, startTimestamp: number, durationDays?: number): Promise<KmsDelegatedUserDecryptEIP712Type>;
+    createDelegatedUserDecryptEIP712(publicKey: Hex, contractAddresses: Address[], delegatorAddress: Address, startTimestamp: number, durationDays?: number): Promise<EIP712TypedData>;
    createEIP712(publicKey: Hex, contractAddresses: Address[], startTimestamp: number, durationDays?: number): Promise<EIP712TypedData>;
    delegatedUserDecrypt(params: DelegatedUserDecryptParams): Promise<Readonly<Record<Handle, ClearValueType>>>;
    encrypt(params: EncryptParams): Promise<EncryptResult>;
-    generateKeypair(): Promise<KeypairType<Hex>>;
+    generateKeypair(): Promise<{
+        publicKey: Hex;
+        privateKey: Hex;
+    }>;
    // (undocumented)
    getAclAddress(): Promise<Address>;
    getPublicKey(): Promise<PublicKeyData | null>;
    getPublicParams(bits: number): Promise<PublicParamsData | null>;
    get initError(): Error | undefined;
    publicDecrypt(handles: Handle[]): Promise<PublicDecryptResult>;
-    requestZKProofVerification(zkProof: ZKProofLike): Promise<InputProofBytesType>;
+    requestZKProofVerification(zkProof: unknown): Promise<EncryptResult>;
    get status(): RelayerSDKStatus;
    terminate(): void;
    userDecrypt(params: UserDecryptParams): Promise<Readonly<Record<Handle, ClearValueType>>>;
@@ -13054,7 +13104,7 @@
    security?: RelayerWebSecurityConfig;
    threads?: number;
    // (undocumented)
-    transports: Record<number, Partial<SDK.FhevmInstanceConfig>>;
+    transports: Record<number, Partial<FhevmInstanceConfig>>;
}

// @public
@@ -14556,6 +14606,7 @@
export interface StoredCredentials {
    contractAddresses: Address[];
    durationDays: number;
+    eip712: StoredEIP712;
    privateKey: Hex;
    publicKey: Hex;
    signature: Hex;
@@ -19560,6 +19611,8 @@
    // (undocumented)
    durationDays: number;
    // (undocumented)
+    eip712: StoredEIP712;
+    // (undocumented)
    handles: Handle[];
    // (undocumented)
    privateKey: Hex;
@@ -20760,8 +20813,6 @@
// @public (undocumented)
export const ZERO_HANDLE: "0x0000000000000000000000000000000000000000000000000000000000000000";

-export { ZKProofLike }
-
// (No @packageDocumentation comment for this package)


</details>

Replace ethers.JsonRpcProvider with viem's createPublicClient + http
transport in both web and node workers. Removes ethers dependency from
the worker bundle.

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment

Projects

None yet

Development

Successfully merging this pull request may close these issues.

1 participant