feat(sdk): add createZamaConfig, chain definitions, and transport system

[ghermet]

Summary

• Add createZamaConfig factory for React SDK with web(), node(), and cleartext() transport helpers
• Introduce FheChain definitions and chain registry with ./chains export
• Add CompositeRelayer for multi-chain support, userDecrypt, publicDecrypt, sdk.allow(), scoped isAllowed, and session storage namespacing
• Updated docs, examples, and tests

Test plan

• Unit tests for createZamaConfig, resolve, composite-relayer, and transports pass
• Typecheck passes across all packages
• Example apps (vite, nextjs, ethers) work with new config API
• Playwright e2e tests pass

🤖 Generated with Claude Code

[github-actions]

Public API Changes

Expand to see full diff

diff -ru a/react-sdk-wagmi.api.md b/react-sdk-wagmi.api.md
--- a/react-sdk-wagmi.api.md	2026-04-21 06:59:07.326913602 +0000
+++ b/react-sdk-wagmi.api.md	2026-04-21 06:59:07.358143279 +0000
@@ -19,6 +19,11 @@
 import { WriteContractArgs } from '@zama-fhe/sdk';
 import { WriteContractConfig } from '@zama-fhe/sdk';
 import { WriteFunctionName } from '@zama-fhe/sdk';
+import { ZamaConfig } from '@zama-fhe/sdk';
+import { ZamaConfigBase } from '@zama-fhe/sdk';
+
+// @public
+export function createZamaConfig(params: ZamaConfigWagmi): ZamaConfig;
 
 // @public
 export class WagmiSigner implements GenericSigner {
@@ -47,6 +52,20 @@
     config: Config;
 }
 
+// @public
+export interface ZamaConfigWagmi<T = Config> extends ZamaConfigBase {
+    // (undocumented)
+    ethers?: never;
+    // (undocumented)
+    relayer?: never;
+    // (undocumented)
+    signer?: never;
+    // (undocumented)
+    viem?: never;
+    // (undocumented)
+    wagmiConfig: T;
+}
+
 // (No @packageDocumentation comment for this package)
 

diff -ru a/react-sdk.api.md b/react-sdk.api.md
--- a/react-sdk.api.md 2026-04-21 06:59:07.329913609 +0000
+++ b/react-sdk.api.md 2026-04-21 06:59:07.358160986 +0000
@@ -8,49 +8,753 @@
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 { ACL_TOPICS } from '@zama-fhe/sdk';
+import { AclEvent } from '@zama-fhe/sdk';
+import { AclPausedError } from '@zama-fhe/sdk';
import { Address } from '@zama-fhe/sdk';
+import { allowanceContract } from '@zama-fhe/sdk';
+import { allowMutationOptions } from '@zama-fhe/sdk/query';
+import { ApprovalFailedError } from '@zama-fhe/sdk';
+import { approveContract } from '@zama-fhe/sdk';
+import { ApproveSubmittedEvent } from '@zama-fhe/sdk';
+import { approveUnderlyingMutationOptions } from '@zama-fhe/sdk/query';
import { ApproveUnderlyingParams } from '@zama-fhe/sdk/query';
+import { ApproveUnderlyingSubmittedEvent } from '@zama-fhe/sdk';
+import { BalanceCheckUnavailableError } from '@zama-fhe/sdk';
+import { balanceOfContract } from '@zama-fhe/sdk';
+import { BaseEvent } from '@zama-fhe/sdk';
import { BatchBalancesResult } from '@zama-fhe/sdk';
+import { BatchDecryptAsOptions } from '@zama-fhe/sdk';
+import { batchDecryptBalancesAsMutationOptions } from '@zama-fhe/sdk/query';
import { BatchDecryptBalancesAsParams } from '@zama-fhe/sdk/query';
+import { ChromeSessionStorage } from '@zama-fhe/sdk';
+import { chromeSessionStorage } from '@zama-fhe/sdk';
+import { clearPendingUnshield } from '@zama-fhe/sdk';
import { ClearValueType } from '@zama-fhe/sdk';
+import { confidentialApproveMutationOptions } from '@zama-fhe/sdk/query';
import { ConfidentialApproveParams } from '@zama-fhe/sdk/query';
+import { confidentialBalanceOfContract } from '@zama-fhe/sdk';
+import { confidentialBalanceQueryOptions } from '@zama-fhe/sdk/query';
+import { confidentialBalancesQueryOptions } from '@zama-fhe/sdk/query';
+import { confidentialIsApprovedQueryOptions } from '@zama-fhe/sdk/query';
+import { confidentialTotalSupplyContract } from '@zama-fhe/sdk';
+import { confidentialTransferContract } from '@zama-fhe/sdk';
+import { ConfidentialTransferEvent } from '@zama-fhe/sdk';
+import { confidentialTransferFromContract } from '@zama-fhe/sdk';
+import { confidentialTransferFromMutationOptions } from '@zama-fhe/sdk/query';
import { ConfidentialTransferFromParams } from '@zama-fhe/sdk/query';
+import { confidentialTransferMutationOptions } from '@zama-fhe/sdk/query';
import { ConfidentialTransferParams } from '@zama-fhe/sdk/query';
+import { ConfigurationError } from '@zama-fhe/sdk';
+import { ContractAbi } from '@zama-fhe/sdk';
+import { createDelegatedUserDecryptEIP712MutationOptions } from '@zama-fhe/sdk/query';
import { CreateDelegatedUserDecryptEIP712Params } from '@zama-fhe/sdk/query';
+import { createEIP712MutationOptions } from '@zama-fhe/sdk/query';
import { CreateEIP712Params } from '@zama-fhe/sdk/query';
+import { CredentialsAllowedEvent } from '@zama-fhe/sdk';
+import { CredentialsCachedEvent } from '@zama-fhe/sdk';
+import { CredentialsCreatedEvent } from '@zama-fhe/sdk';
+import { CredentialsCreatingEvent } from '@zama-fhe/sdk';
+import { CredentialsExpiredEvent } from '@zama-fhe/sdk';
+import { CredentialsLoadingEvent } from '@zama-fhe/sdk';
+import { CredentialsManager } from '@zama-fhe/sdk';
+import { CredentialsManagerConfig } from '@zama-fhe/sdk';
+import { CredentialsRevokedEvent } from '@zama-fhe/sdk';
+import { decimalsContract } from '@zama-fhe/sdk';
+import { decodeAclEvent } from '@zama-fhe/sdk';
+import { decodeAclEvents } from '@zama-fhe/sdk';
+import { decodeConfidentialTransfer } from '@zama-fhe/sdk';
+import { decodeDelegatedForUserDecryption } from '@zama-fhe/sdk';
+import { decodeOnChainEvent } from '@zama-fhe/sdk';
+import { decodeOnChainEvents } from '@zama-fhe/sdk';
+import { decodeRevokedDelegationForUserDecryption } from '@zama-fhe/sdk';
+import { decodeUnwrappedFinalized } from '@zama-fhe/sdk';
+import { decodeUnwrappedStarted } from '@zama-fhe/sdk';
+import { decodeUnwrapRequested } from '@zama-fhe/sdk';
+import { decodeWrapped } from '@zama-fhe/sdk';
+import { decryptBalanceAsMutationOptions } from '@zama-fhe/sdk/query';
import { DecryptBalanceAsParams } from '@zama-fhe/sdk/query';
+import { DecryptEndEvent } from '@zama-fhe/sdk';
+import { DecryptErrorEvent } from '@zama-fhe/sdk';
+import { DecryptHandle } from '@zama-fhe/sdk/query';
+import { DecryptionFailedError } from '@zama-fhe/sdk';
import { DecryptResult } from '@zama-fhe/sdk/query';
+import { DecryptStartEvent } from '@zama-fhe/sdk';
+import { DefaultConfigs } from '@zama-fhe/sdk';
+import { DefaultRegistryAddresses } from '@zama-fhe/sdk';
+import { DelegatedCredentialsManager } from '@zama-fhe/sdk';
+import { DelegatedCredentialsManagerConfig } from '@zama-fhe/sdk';
+import { delegateDecryptionMutationOptions } from '@zama-fhe/sdk/query';
import { DelegateDecryptionParams } from '@zama-fhe/sdk/query';
+import { DelegatedForUserDecryptionEvent } from '@zama-fhe/sdk';
+import { DelegatedStoredCredentials } from '@zama-fhe/sdk';
+import { delegatedUserDecryptMutationOptions } from '@zama-fhe/sdk/query';
import { DelegatedUserDecryptParams } from '@zama-fhe/sdk';
+import { delegateForUserDecryptionContract } from '@zama-fhe/sdk';
+import { DelegationContractIsSelfError } from '@zama-fhe/sdk';
+import { DelegationCooldownError } from '@zama-fhe/sdk';
+import { DelegationDelegateEqualsContractError } from '@zama-fhe/sdk';
+import { DelegationExpirationTooSoonError } from '@zama-fhe/sdk';
+import { DelegationExpiredError } from '@zama-fhe/sdk';
+import { DelegationExpiryUnchangedError } from '@zama-fhe/sdk';
+import { DelegationNotFoundError } from '@zama-fhe/sdk';
+import { DelegationNotPropagatedError } from '@zama-fhe/sdk';
+import { DelegationSelfNotAllowedError } from '@zama-fhe/sdk';
import { DelegationStatusData } from '@zama-fhe/sdk/query';
+import { DelegationStatusQueryConfig } from '@zama-fhe/sdk/query';
+import { delegationStatusQueryOptions } from '@zama-fhe/sdk/query';
import { EIP712TypedData } from '@zama-fhe/sdk';
+import { EncryptEndEvent } from '@zama-fhe/sdk';
+import { EncryptErrorEvent } from '@zama-fhe/sdk';
+import { EncryptInput } from '@zama-fhe/sdk';
+import { EncryptionFailedError } from '@zama-fhe/sdk';
+import { encryptMutationOptions } from '@zama-fhe/sdk/query';
import { EncryptParams } from '@zama-fhe/sdk';
+import { EncryptResult } from '@zama-fhe/sdk';
+import { EncryptStartEvent } from '@zama-fhe/sdk';
+import { ERC20ReadFailedError } from '@zama-fhe/sdk';
+import { ERC7984_INTERFACE_ID } from '@zama-fhe/sdk';
+import { ERC7984_WRAPPER_INTERFACE_ID } from '@zama-fhe/sdk';
+import { ERC7984_WRAPPER_INTERFACE_ID_LEGACY } from '@zama-fhe/sdk';
+import { ExtendedFhevmInstanceConfig } from '@zama-fhe/sdk';
+import { FheTypeName } from '@zama-fhe/sdk';
+import { FhevmInstanceConfig } from '@zama-fhe/sdk';
+import { filterQueryOptions } from '@zama-fhe/sdk/query';
+import { finalizeUnwrapContract } from '@zama-fhe/sdk';
+import { finalizeUnwrapMutationOptions } from '@zama-fhe/sdk/query';
import { FinalizeUnwrapParams } from '@zama-fhe/sdk/query';
+import { FinalizeUnwrapSubmittedEvent } from '@zama-fhe/sdk';
+import { findDelegatedForUserDecryption } from '@zama-fhe/sdk';
+import { findRevokedDelegationForUserDecryption } from '@zama-fhe/sdk';
+import { findUnwrapRequested } from '@zama-fhe/sdk';
+import { findWrapped } from '@zama-fhe/sdk';
+import { generateKeypairMutationOptions } from '@zama-fhe/sdk/query';
import { GenericSigner } from '@zama-fhe/sdk';
import { GenericStorage } from '@zama-fhe/sdk';
+import { getDelegationExpiryContract } from '@zama-fhe/sdk';
+import { Handle } from '@zama-fhe/sdk';
+import { HardhatConfig } from '@zama-fhe/sdk';
+import { hashFn } from '@zama-fhe/sdk/query';
+import { Hex } from '@zama-fhe/sdk';
+import { IndexedDBStorage } from '@zama-fhe/sdk';
+import { indexedDBStorage } from '@zama-fhe/sdk';
+import { inferredTotalSupplyContract } from '@zama-fhe/sdk';
+import { InputProofBytesType } from '@zama-fhe/sdk';
+import { InsufficientConfidentialBalanceError } from '@zama-fhe/sdk';
+import { InsufficientERC20BalanceError } from '@zama-fhe/sdk';
+import { InvalidKeypairError } from '@zama-fhe/sdk';
+import { isAllowedQueryOptions } from '@zama-fhe/sdk/query';
+import { isConfidentialQueryOptions } from '@zama-fhe/sdk/query';
+import { isConfidentialTokenContract } from '@zama-fhe/sdk';
+import { isConfidentialWrapperContract } from '@zama-fhe/sdk';
+import { isHandleDelegatedContract } from '@zama-fhe/sdk';
+import { isOperatorContract } from '@zama-fhe/sdk';
+import { isWrapperQueryOptions } from '@zama-fhe/sdk/query';
+import { isZeroHandle } from '@zama-fhe/sdk';
+import { KeypairExpiredError } from '@zama-fhe/sdk';
+import { KeypairType } from '@zama-fhe/sdk';
+import { KmsDelegatedUserDecryptEIP712Type } from '@zama-fhe/sdk';
+import { ListPairsOptions } from '@zama-fhe/sdk';
+import { ListPairsQueryConfig } from '@zama-fhe/sdk/query';
+import { listPairsQueryOptions } from '@zama-fhe/sdk/query';
+import { loadPendingUnshield } from '@zama-fhe/sdk';
+import { MainnetConfig } from '@zama-fhe/sdk';
+import { matchAclRevert } from '@zama-fhe/sdk';
+import { matchZamaError } from '@zama-fhe/sdk';
+import { MemoryStorage } from '@zama-fhe/sdk';
+import { memoryStorage } from '@zama-fhe/sdk';
+import { nameContract } from '@zama-fhe/sdk';
+import { NetworkType } from '@zama-fhe/sdk';
+import { NoCiphertextError } from '@zama-fhe/sdk';
+import { OnChainEvent } from '@zama-fhe/sdk';
import { PaginatedResult } from '@zama-fhe/sdk';
import { PropsWithChildren } from 'react';
+import { publicDecryptMutationOptions } from '@zama-fhe/sdk/query';
+import { PublicDecryptResult } from '@zama-fhe/sdk';
import { PublicKeyData } from '@zama-fhe/sdk';
+import { publicKeyQueryOptions } from '@zama-fhe/sdk/query';
+import { publicParamsQueryOptions } from '@zama-fhe/sdk/query';
+import { QueryKey } from '@tanstack/react-query';
+import { rateContract } from '@zama-fhe/sdk';
+import { RawLog } from '@zama-fhe/sdk';
+import { ReadContractArgs } from '@zama-fhe/sdk';
+import { ReadContractConfig } from '@zama-fhe/sdk';
+import { ReadContractReturnType } from '@zama-fhe/sdk';
+import { ReadFunctionName } from '@zama-fhe/sdk';
import { ReadonlyToken } from '@zama-fhe/sdk';
+import { RelayerRequestFailedError } from '@zama-fhe/sdk';
import { RelayerSDK } from '@zama-fhe/sdk';
+import { RelayerSDKStatus } from '@zama-fhe/sdk';
+import { RelayerWeb } from '@zama-fhe/sdk';
+import { RelayerWebConfig } from '@zama-fhe/sdk';
+import { RelayerWebSecurityConfig } from '@zama-fhe/sdk';
+import { requestZKProofVerificationMutationOptions } from '@zama-fhe/sdk/query';
+import { resumeUnshieldMutationOptions } from '@zama-fhe/sdk/query';
import { ResumeUnshieldParams } from '@zama-fhe/sdk/query';
+import { RevokedDelegationForUserDecryptionEvent } from '@zama-fhe/sdk';
+import { revokeDelegationContract } from '@zama-fhe/sdk';
+import { revokeDelegationMutationOptions } from '@zama-fhe/sdk/query';
import { RevokeDelegationParams } from '@zama-fhe/sdk/query';
+import { revokeMutationOptions } from '@zama-fhe/sdk/query';
+import { revokeSessionMutationOptions } from '@zama-fhe/sdk/query';
+import { savePendingUnshield } from '@zama-fhe/sdk';
+import { SepoliaConfig } from '@zama-fhe/sdk';
+import { SessionExpiredEvent } from '@zama-fhe/sdk';
+import { setOperatorContract } from '@zama-fhe/sdk';
+import { ShieldCallbacks } from '@zama-fhe/sdk';
+import { shieldMutationOptions } from '@zama-fhe/sdk/query';
import { ShieldParams } from '@zama-fhe/sdk/query';
+import { ShieldSubmittedEvent } from '@zama-fhe/sdk';
+import { signerAddressQueryOptions } from '@zama-fhe/sdk/query';
+import { SigningFailedError } from '@zama-fhe/sdk';
+import { SigningRejectedError } from '@zama-fhe/sdk';
+import { StoredCredentials } from '@zama-fhe/sdk';
+import { supportsInterfaceContract } from '@zama-fhe/sdk';
+import { symbolContract } from '@zama-fhe/sdk';
+import { Token } from '@zama-fhe/sdk';
+import { TOKEN_TOPICS } from '@zama-fhe/sdk';
import { TokenMetadata } from '@zama-fhe/sdk/query';
+import { tokenMetadataQueryOptions } from '@zama-fhe/sdk/query';
import { TokenWrapperPair } from '@zama-fhe/sdk';
import { TokenWrapperPairWithMetadata } from '@zama-fhe/sdk';
+import { Topics } from '@zama-fhe/sdk';
+import { totalSupplyContract } from '@zama-fhe/sdk';
+import { totalSupplyQueryOptions } from '@zama-fhe/sdk/query';
+import { TransactionErrorEvent } from '@zama-fhe/sdk';
+import { TransactionReceipt } from '@zama-fhe/sdk';
import { TransactionResult } from '@zama-fhe/sdk';
+import { TransactionRevertedError } from '@zama-fhe/sdk';
+import { TransferCallbacks } from '@zama-fhe/sdk';
+import { TransferFromSubmittedEvent } from '@zama-fhe/sdk';
+import { TransferSubmittedEvent } from '@zama-fhe/sdk';
+import { underlyingAllowanceQueryOptions } from '@zama-fhe/sdk/query';
+import { underlyingContract } from '@zama-fhe/sdk';
+import { unshieldAllMutationOptions } from '@zama-fhe/sdk/query';
import { UnshieldAllParams } from '@zama-fhe/sdk/query';
+import { UnshieldCallbacks } from '@zama-fhe/sdk';
+import { unshieldMutationOptions } from '@zama-fhe/sdk/query';
import { UnshieldParams } from '@zama-fhe/sdk/query';
+import { UnshieldPhase1SubmittedEvent } from '@zama-fhe/sdk';
+import { UnshieldPhase2StartedEvent } from '@zama-fhe/sdk';
+import { UnshieldPhase2SubmittedEvent } from '@zama-fhe/sdk';
+import { unwrapAllMutationOptions } from '@zama-fhe/sdk/query';
+import { unwrapContract } from '@zama-fhe/sdk';
+import { unwrapFromBalanceContract } from '@zama-fhe/sdk';
+import { unwrapMutationOptions } from '@zama-fhe/sdk/query';
import { UnwrapParams } from '@zama-fhe/sdk/query';
+import { UnwrappedFinalizedEvent } from '@zama-fhe/sdk';
+import { UnwrappedStartedEvent } from '@zama-fhe/sdk';
+import { UnwrapRequestedEvent } from '@zama-fhe/sdk';
+import { UnwrapSubmittedEvent } from '@zama-fhe/sdk';
import { UseMutationOptions } from '@tanstack/react-query';
import { UseMutationResult } from '@tanstack/react-query';
import { UseQueryOptions } from '@tanstack/react-query';
+import { UserDecryptParams } from '@zama-fhe/sdk';
import { UserDecryptQueryConfig } from '@zama-fhe/sdk/query';
+import { userDecryptQueryOptions } from '@zama-fhe/sdk/query';
+import { wrapContract } from '@zama-fhe/sdk';
+import { WrappedEvent } from '@zama-fhe/sdk';
+import { wrapperDiscoveryQueryOptions } from '@zama-fhe/sdk/query';
+import { WrappersRegistry } from '@zama-fhe/sdk';
+import { WrappersRegistryConfig } from '@zama-fhe/sdk';
+import { WriteContractArgs } from '@zama-fhe/sdk';
+import { WriteContractConfig } from '@zama-fhe/sdk';
+import { WriteFunctionName } from '@zama-fhe/sdk';
+import { ZamaConfig } from '@zama-fhe/sdk';
+import { ZamaError } from '@zama-fhe/sdk';
+import { ZamaErrorCode } from '@zama-fhe/sdk';
+import { zamaQueryKeys } from '@zama-fhe/sdk/query';
import { ZamaSDK } from '@zama-fhe/sdk';
+import { ZamaSDKConfig } from '@zama-fhe/sdk';
+import { ZamaSDKEvent } from '@zama-fhe/sdk';
+import { ZamaSDKEventInput } from '@zama-fhe/sdk';
import { ZamaSDKEventListener } from '@zama-fhe/sdk';
+import { ZamaSDKEvents } from '@zama-fhe/sdk';
+import { ZamaSDKEventType } from '@zama-fhe/sdk';
+import { ZERO_HANDLE } from '@zama-fhe/sdk';
import { ZKProofLike } from '@zama-fhe/sdk';

+export { ACL_TOPICS }
+
+export { AclEvent }
+
+export { AclPausedError }
+
+export { Address }
+
+export { allowanceContract }
+
+export { allowMutationOptions }
+
+export { ApprovalFailedError }
+
+export { approveContract }
+
+export { ApproveSubmittedEvent }
+
+export { approveUnderlyingMutationOptions }
+
+export { ApproveUnderlyingParams }
+
+export { ApproveUnderlyingSubmittedEvent }
+
+export { BalanceCheckUnavailableError }
+
+export { balanceOfContract }
+
+export { BaseEvent }
+
+export { BatchBalancesResult }
+
+export { BatchDecryptAsOptions }
+
+export { batchDecryptBalancesAsMutationOptions }
+
+export { BatchDecryptBalancesAsParams }
+
+export { ChromeSessionStorage }
+
+export { chromeSessionStorage }
+
+export { clearPendingUnshield }
+
+export { ClearValueType }
+
+export { confidentialApproveMutationOptions }
+
+export { ConfidentialApproveParams }
+
+export { confidentialBalanceOfContract }
+
+export { confidentialBalanceQueryOptions }
+
+export { confidentialBalancesQueryOptions }
+
+export { confidentialIsApprovedQueryOptions }
+
+export { confidentialTotalSupplyContract }
+
+export { confidentialTransferContract }
+
+export { ConfidentialTransferEvent }
+
+export { confidentialTransferFromContract }
+
+export { confidentialTransferFromMutationOptions }
+
+export { ConfidentialTransferFromParams }
+
+export { confidentialTransferMutationOptions }
+
+export { ConfidentialTransferParams }
+
+export { ConfigurationError }
+
+export { ContractAbi }
+
+export { createDelegatedUserDecryptEIP712MutationOptions }
+
+export { CreateDelegatedUserDecryptEIP712Params }
+
+export { createEIP712MutationOptions }
+
+export { CreateEIP712Params }
+
+export { CredentialsAllowedEvent }
+
+export { CredentialsCachedEvent }
+
+export { CredentialsCreatedEvent }
+
+export { CredentialsCreatingEvent }
+
+export { CredentialsExpiredEvent }
+
+export { CredentialsLoadingEvent }
+
+export { CredentialsManager }
+
+export { CredentialsManagerConfig }
+
+export { CredentialsRevokedEvent }
+
+export { decimalsContract }
+
+export { decodeAclEvent }
+
+export { decodeAclEvents }
+
+export { decodeConfidentialTransfer }
+
+export { decodeDelegatedForUserDecryption }
+
+export { decodeOnChainEvent }
+
+export { decodeOnChainEvents }
+
+export { decodeRevokedDelegationForUserDecryption }
+
+export { decodeUnwrappedFinalized }
+
+export { decodeUnwrappedStarted }
+
+export { decodeUnwrapRequested }
+
+export { decodeWrapped }
+
+export { decryptBalanceAsMutationOptions }
+
+export { DecryptBalanceAsParams }
+
+export { DecryptEndEvent }
+
+export { DecryptErrorEvent }
+
+export { DecryptHandle }
+
+export { DecryptionFailedError }
+
+export { DecryptResult }
+
+export { DecryptStartEvent }
+
+export { DefaultConfigs }
+
+export { DefaultRegistryAddresses }
+
+export { DelegatedCredentialsManager }
+
+export { DelegatedCredentialsManagerConfig }
+
+export { delegateDecryptionMutationOptions }
+
+export { DelegateDecryptionParams }
+
+export { DelegatedForUserDecryptionEvent }
+
+export { DelegatedStoredCredentials }
+
+export { delegatedUserDecryptMutationOptions }
+
+export { DelegatedUserDecryptParams }
+
+export { delegateForUserDecryptionContract }
+
+export { DelegationContractIsSelfError }
+
+export { DelegationCooldownError }
+
+export { DelegationDelegateEqualsContractError }
+
+export { DelegationExpirationTooSoonError }
+
+export { DelegationExpiredError }
+
+export { DelegationExpiryUnchangedError }
+
+export { DelegationNotFoundError }
+
+export { DelegationNotPropagatedError }
+
+export { DelegationSelfNotAllowedError }
+
+export { DelegationStatusData }
+
+export { DelegationStatusQueryConfig }
+
+export { delegationStatusQueryOptions }
+
+export { EIP712TypedData }
+
+export { EncryptEndEvent }
+
+export { EncryptErrorEvent }
+
+export { EncryptInput }
+
+export { EncryptionFailedError }
+
+export { encryptMutationOptions }
+
+export { EncryptParams }
+
+export { EncryptResult }
+
+export { EncryptStartEvent }
+
+export { ERC20ReadFailedError }
+
+export { ERC7984_INTERFACE_ID }
+
+export { ERC7984_WRAPPER_INTERFACE_ID }
+
+export { ERC7984_WRAPPER_INTERFACE_ID_LEGACY }
+
+export { ExtendedFhevmInstanceConfig }
+
+export { FheTypeName }
+
+export { FhevmInstanceConfig }
+
+export { filterQueryOptions }
+
+export { finalizeUnwrapContract }
+
+export { finalizeUnwrapMutationOptions }
+
+export { FinalizeUnwrapParams }
+
+export { FinalizeUnwrapSubmittedEvent }
+
+export { findDelegatedForUserDecryption }
+
+export { findRevokedDelegationForUserDecryption }
+
+export { findUnwrapRequested }
+
+export { findWrapped }
+
+export { generateKeypairMutationOptions }
+
+export { GenericSigner }
+
+export { GenericStorage }
+
+export { getDelegationExpiryContract }
+
+export { Handle }
+
+export { HardhatConfig }
+
+export { hashFn }
+
+export { Hex }
+
+export { IndexedDBStorage }
+
+export { indexedDBStorage }
+
+export { inferredTotalSupplyContract }
+
+export { InputProofBytesType }
+
+export { InsufficientConfidentialBalanceError }
+
+export { InsufficientERC20BalanceError }
+
+export { InvalidKeypairError }
+
+export { isAllowedQueryOptions }
+
+export { isConfidentialQueryOptions }
+
+export { isConfidentialTokenContract }
+
+export { isConfidentialWrapperContract }
+
+export { isHandleDelegatedContract }
+
+export { isOperatorContract }
+
+export { isWrapperQueryOptions }
+
+export { isZeroHandle }
+
+export { KeypairExpiredError }
+
+export { KeypairType }
+
+export { KmsDelegatedUserDecryptEIP712Type }
+
+export { ListPairsOptions }
+
+export { ListPairsQueryConfig }
+
+export { listPairsQueryOptions }
+
+export { loadPendingUnshield }
+
+export { MainnetConfig }
+
+export { matchAclRevert }
+
+export { matchZamaError }
+
+export { MemoryStorage }
+
+export { memoryStorage }
+
+export { nameContract }
+
+export { NetworkType }
+
+export { NoCiphertextError }
+
+export { OnChainEvent }
+
+// @public (undocumented)
+export type OptimisticBalanceSnapshot = [QueryKey, bigint | undefined][];
+
+// @public
+export interface OptimisticMutateContext {

• // (undocumented)
• callerContext?: unknown;
• // (undocumented)
• snapshot: OptimisticBalanceSnapshot;
  +}

+export { PaginatedResult }
+
+export { publicDecryptMutationOptions }
+
+export { PublicDecryptResult }
+
+export { publicKeyQueryOptions }
+
+export { publicParamsQueryOptions }
+
+export { rateContract }
+
+export { RawLog }
+
+export { ReadContractArgs }
+
+export { ReadContractConfig }
+
+export { ReadContractReturnType }
+
+export { ReadFunctionName }
+
+export { ReadonlyToken }
+
+export { RelayerRequestFailedError }
+
+export { RelayerSDK }
+
+export { RelayerSDKStatus }
+
+export { RelayerWeb }
+
+export { RelayerWebConfig }
+
+export { RelayerWebSecurityConfig }
+
+export { requestZKProofVerificationMutationOptions }
+
+export { resumeUnshieldMutationOptions }
+
+export { ResumeUnshieldParams }
+
+export { RevokedDelegationForUserDecryptionEvent }
+
+export { revokeDelegationContract }
+
+export { revokeDelegationMutationOptions }
+
+export { RevokeDelegationParams }
+
+export { revokeMutationOptions }
+
+export { revokeSessionMutationOptions }
+
+export { savePendingUnshield }
+
+export { SepoliaConfig }
+
+export { SessionExpiredEvent }
+
+export { setOperatorContract }
+
+export { ShieldCallbacks }
+
+export { shieldMutationOptions }
+
+export { ShieldParams }
+
+export { ShieldSubmittedEvent }
+
+export { signerAddressQueryOptions }
+
+export { SigningFailedError }
+
+export { SigningRejectedError }
+
+export { StoredCredentials }
+
+export { supportsInterfaceContract }
+
+export { symbolContract }
+
+export { Token }
+
+export { TOKEN_TOPICS }
+
+export { TokenMetadata }
+
+export { tokenMetadataQueryOptions }
+
+export { TokenWrapperPair }
+
+export { TokenWrapperPairWithMetadata }
+
+export { Topics }
+
+export { totalSupplyContract }
+
+export { totalSupplyQueryOptions }
+
+export { TransactionErrorEvent }
+
+export { TransactionReceipt }
+
+export { TransactionResult }
+
+export { TransactionRevertedError }
+
+export { TransferCallbacks }
+
+export { TransferFromSubmittedEvent }
+
+export { TransferSubmittedEvent }
+
+export { underlyingAllowanceQueryOptions }
+
+export { underlyingContract }
+
+export { unshieldAllMutationOptions }
+
+export { UnshieldAllParams }
+
+export { UnshieldCallbacks }
+
+export { unshieldMutationOptions }
+
+export { UnshieldParams }
+
+export { UnshieldPhase1SubmittedEvent }
+
+export { UnshieldPhase2StartedEvent }
+
+export { UnshieldPhase2SubmittedEvent }
+
+export { unwrapAllMutationOptions }
+
+export { unwrapContract }
+
+export { unwrapFromBalanceContract }
+
+export { unwrapMutationOptions }
+
+export { UnwrapParams }
+
+export { UnwrappedFinalizedEvent }
+
+export { UnwrappedStartedEvent }
+
+export { UnwrapRequestedEvent }
+
+export { UnwrapSubmittedEvent }
+
// @public
export function useAllow(options?: UseMutationOptions<void, Error, Address[]>): _$_tanstack_react_query0.UseMutationResult<void, Error, 0x${string}[], unknown>;

@@ -220,6 +924,12 @@
publicParamsId: string;
} | null, Error>;

+export { UserDecryptParams }
+
+export { UserDecryptQueryConfig }
+
+export { userDecryptQueryOptions }
+
// @public
export function useReadonlyToken(address: Address): _$_zama_fhe_sdk0.ReadonlyToken;

@@ -340,21 +1050,54 @@
// @public
export function useZamaSDK(): ZamaSDK;

+export { wrapContract }
+
+export { WrappedEvent }
+
+export { wrapperDiscoveryQueryOptions }
+
+export { WrappersRegistry }
+
+export { WrappersRegistryConfig }
+
+export { WriteContractArgs }
+
+export { WriteContractConfig }
+
+export { WriteFunctionName }
+
+export { ZamaError }
+
+export { ZamaErrorCode }
+
// @public
-export function ZamaProvider(input: ZamaProviderProps): _$react_jsx_runtime0.JSX.Element;
+export function ZamaProvider(props: ZamaProviderProps): _$react_jsx_runtime0.JSX.Element;

+// Warning: (ae-forgotten-export) The symbol "ZamaProviderConfigProps" needs to be exported by the entry point index.d.ts
+// Warning: (ae-forgotten-export) The symbol "ZamaProviderLegacyProps" needs to be exported by the entry point index.d.ts
+//
// @public
-export interface ZamaProviderProps extends PropsWithChildren {

• keypairTTL?: number;
• onEvent?: ZamaSDKEventListener;
• registryAddresses?: Record<number, Address>;
• registryTTL?: number;
• relayer: RelayerSDK;
• sessionStorage?: GenericStorage;
• sessionTTL?: number;
• signer: GenericSigner;
• storage: GenericStorage;
  -}
  +export type ZamaProviderProps = ZamaProviderConfigProps | ZamaProviderLegacyProps;

+export { zamaQueryKeys }
+
+export { ZamaSDK }
+
+export { ZamaSDKConfig }
+
+export { ZamaSDKEvent }
+
+export { ZamaSDKEventInput }
+
+export { ZamaSDKEventListener }
+
+export { ZamaSDKEvents }
+
+export { ZamaSDKEventType }
+
+export { ZERO_HANDLE }
+
+export { ZKProofLike }

// (No @packageDocumentation comment for this package)

diff -ru a/sdk-node.api.md b/sdk-node.api.md
--- a/sdk-node.api.md 2026-04-21 06:59:07.333913618 +0000
+++ b/sdk-node.api.md 2026-04-21 06:59:07.357808241 +0000
@@ -8,7 +8,6 @@
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';
@@ -481,14 +480,13 @@

// @public (undocumented)
export interface RelayerNodeConfig {

• // Warning: (ae-forgotten-export) The symbol "ExtendedFhevmInstanceConfig" needs to be exported by the entry point index.d.ts
• chain: ExtendedFhevmInstanceConfig;
  fheArtifactCacheTTL?: number;
  fheArtifactStorage?: GenericStorage;

• getChainId: () => Promise;
  logger?: GenericLogger;
  // (undocumented)
  poolSize?: number;
• // (undocumented)
• transports: Record<number, Partial<FhevmInstanceConfig_2>>;
  }

// @public
diff -ru a/sdk-query.api.md b/sdk-query.api.md
--- a/sdk-query.api.md 2026-04-21 06:59:07.336913624 +0000
+++ b/sdk-query.api.md 2026-04-21 06:59:07.357835898 +0000
@@ -11,6 +11,7 @@
import { ContractFunctionArgs } from 'viem';
import { ContractFunctionName } from 'viem';
import { ContractFunctionReturnType } from 'viem';
+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';
@@ -1382,6 +1383,8 @@

// @public
export interface ZamaSDKConfig {

• // Warning: (ae-forgotten-export) The symbol "FheChain" needs to be exported by the entry point index.d.ts
• chains?: readonly FheChain[];
  keypairTTL?: number;
  onEvent?: ZamaSDKEventListener;
  registryAddresses?: Record<number, Address>;
  diff -ru a/sdk.api.md b/sdk.api.md
  --- a/sdk.api.md 2026-04-21 06:59:07.345913645 +0000
  +++ b/sdk.api.md 2026-04-21 06:59:07.357913672 +0000
  @@ -11,6 +11,7 @@
  import { ContractFunctionArgs } from 'viem';
  import { ContractFunctionName } from 'viem';
  import { ContractFunctionReturnType } from 'viem';
  +import { EIP1193Provider } from 'viem';
  import { FheTypeName } from '@zama-fhe/relayer-sdk/bundle';
  import { FhevmInstanceConfig } from '@zama-fhe/relayer-sdk/bundle';
  import { Hex } from 'viem';
  @@ -18,9 +19,13 @@
  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 { Provider } from 'ethers';
  +import { PublicClient } from 'viem';
  import { PublicDecryptResults } from '@zama-fhe/relayer-sdk/bundle';
  import * as SDK from '@zama-fhe/relayer-sdk/bundle';
  +import { Signer } from 'ethers';
  import { UserDecryptResults } from '@zama-fhe/relayer-sdk/bundle';
  +import { WalletClient } from 'viem';
  import { ZKProofLike } from '@zama-fhe/relayer-sdk/bundle';

// @public
@@ -528,6 +533,11 @@
onError?: (error: Error, address: Address) => bigint;
}

+// Warning: (ae-forgotten-export) The symbol "ResolvedChainTransport" needs to be exported by the entry point index.d.ts
+//
+// @public (undocumented)
+export function buildRelayer(chainTransports: Map<number, ResolvedChainTransport>, resolveChainId: () => Promise): RelayerSDK;
+
// @public
export class ChromeSessionStorage implements GenericStorage {
// (undocumented)
@@ -544,6 +554,19 @@
// @public
export function clearPendingUnshield(storage: GenericStorage, wrapperAddress: Address): Promise;

+// Warning: (ae-forgotten-export) The symbol "CleartextChainConfig" needs to be exported by the entry point index.d.ts
+//
+// @public
+export function cleartext(chain: CleartextChainConfig): CleartextTransportConfig;
+
+// @public
+export interface CleartextTransportConfig {

• // (undocumented)
• chain: CleartextChainConfig;
• // (undocumented)
• readonly type: "cleartext";
  +}

export { ClearValueType }

// @public
@@ -5847,6 +5870,12 @@
// @public
export type ContractAbi = Abi | readonly unknown[];

+// @public
+export function createZamaConfig(params: CreateZamaConfigBaseParams): ZamaConfig;
+
+// @public
+export type CreateZamaConfigBaseParams = ZamaConfigViem | ZamaConfigEthers | ZamaConfigCustomSigner;
+
// @public (undocumented)
export interface CredentialsAllowedEvent extends BaseEvent {
contractAddresses?: Address[];
@@ -6174,6 +6203,9 @@
}

// @public
+export const DefaultConfigs: Record<number, ExtendedFhevmInstanceConfig>;
+
+// @public
export const DefaultRegistryAddresses: Record<number, Address>;

// Warning: (ae-forgotten-export) The symbol "EncryptedCredentials" needs to be exported by the entry point index.d.ts
@@ -6456,7 +6488,18 @@
export const ERC7984_WRAPPER_INTERFACE_ID: "0x1f1c62b2";

// @public
-export const ERC7984_WRAPPER_INTERFACE_ID_LEGACY: "0xf1f4c25a";
+export const ERC7984_WRAPPER_INTERFACE_ID_LEGACY: "0xd04584ba";
+
+// @public
+export interface ExtendedFhevmInstanceConfig extends FhevmInstanceConfig {

• registryAddress: Address | undefined;
  +}

+// @public (undocumented)
+export interface FheChain extends Omit<ExtendedFhevmInstanceConfig, "chainId"> {

• // (undocumented)
• readonly id: number;
  +}

export { FheTypeName }

@@ -11584,6 +11627,19 @@
constructor(message: string, options?: ErrorOptions);
}

+// Warning: (ae-forgotten-export) The symbol "NodeRelayerOptions" needs to be exported by the entry point index.d.ts
+//
+// @public
+export function node(chain?: Partial, relayer?: NodeRelayerOptions): NodeTransportConfig;
+
+// @public
+export interface NodeTransportConfig {

• chain?: Partial;
• relayer?: NodeRelayerOptions;
• // (undocumented)
• readonly type: "node";
  +}

// @public
export type OnChainEvent = ConfidentialTransferEvent | WrappedEvent | UnwrapRequestedEvent | UnwrappedFinalizedEvent | UnwrappedStartedEvent;

@@ -13046,15 +13102,13 @@

// @public
export interface RelayerWebConfig {

• chain: ExtendedFhevmInstanceConfig;
  fheArtifactCacheTTL?: number;
  fheArtifactStorage?: GenericStorage;

• getChainId: () => Promise;
  logger?: GenericLogger;
  onStatusChange?: (status: RelayerSDKStatus, error?: Error) => void;
  security?: RelayerWebSecurityConfig;
  threads?: number;
• // (undocumented)
• transports: Record<number, Partial<SDK.FhevmInstanceConfig>>;
  }

// @public
@@ -13063,6 +13117,15 @@
integrityCheck?: boolean;
}

+// @public (undocumented)
+export function resolveChainTransports(chains: FheChain[], transports: Record<number, TransportConfig> | undefined, chainIds: number[]): Map<number, ResolvedChainTransport>;
+
+// @public (undocumented)
+export function resolveStorage(storage: GenericStorage | undefined, sessionStorage: GenericStorage | undefined): {

• storage: GenericStorage;
• sessionStorage: GenericStorage;
  +};

// @public
export interface RevokedDelegationForUserDecryptionEvent {
readonly contractAddress: Address;
@@ -15846,6 +15909,9 @@
}

// @public
+export type TransportConfig = WebTransportConfig | NodeTransportConfig | CleartextTransportConfig;
+
+// @public
export function underlyingContract(wrapperAddress: Address): {
readonly address: 0x${string};
readonly abi: readonly [{
@@ -19575,6 +19641,19 @@
startTimestamp: number;
}

+// Warning: (ae-forgotten-export) The symbol "WebRelayerOptions" needs to be exported by the entry point index.d.ts
+//
+// @public
+export function web(chain?: Partial, relayer?: WebRelayerOptions): WebTransportConfig;
+
+// @public
+export interface WebTransportConfig {

• chain?: Partial;
• relayer?: WebRelayerOptions;
• // (undocumented)
• readonly type: "web";
  +}

// @public
export function wrapContract(wrapperAddress: Address, to: Address, amount: bigint): {
readonly address: 0x${string};
@@ -20630,6 +20709,92 @@
export type WriteFunctionName = ContractFunctionName<TAbi, "nonpayable" | "payable">;

// @public
+export interface ZamaConfig {

• // @internal (undocumented)
• readonly chains: readonly FheChain[];
• // @internal (undocumented)
• readonly keypairTTL: number | undefined;
• // @internal (undocumented)
• readonly onEvent: ZamaSDKEventListener | undefined;
• // @internal (undocumented)
• readonly registryTTL: number | undefined;
• // @internal (undocumented)
• readonly relayer: RelayerSDK;
• // @internal (undocumented)
• readonly sessionStorage: GenericStorage;
• // @internal (undocumented)
• readonly sessionTTL: number | "infinite" | undefined;
• // @internal (undocumented)
• readonly signer: GenericSigner;
• // @internal (undocumented)
• readonly storage: GenericStorage;
  +}

+// @public
+export interface ZamaConfigBase {

• chains: FheChain[];
• keypairTTL?: number;
• onEvent?: ZamaSDKEventListener;
• registryTTL?: number;
• sessionStorage?: GenericStorage;
• sessionTTL?: number | "infinite";
• storage?: GenericStorage;
• transports?: Record<number, TransportConfig>;
  +}

+// @public
+export interface ZamaConfigCustomSigner extends ZamaConfigBase {

• // (undocumented)
• ethers?: never;
• // (undocumented)
• relayer?: never;
• // (undocumented)
• signer: GenericSigner;
• // (undocumented)
• transports: Record<number, TransportConfig>;
• // (undocumented)
• viem?: never;
  +}

+// @public
+export interface ZamaConfigEthers extends ZamaConfigBase {

• // (undocumented)
• ethers: {

•    ethereum: EIP1193Provider;
  

• } | {

•    signer: Signer;
  

• } | {

•    provider: Provider;
  

• };
• // (undocumented)
• relayer?: never;
• // (undocumented)
• signer?: never;
• // (undocumented)
• transports: Record<number, TransportConfig>;
• // (undocumented)
• viem?: never;
  +}

+// @public
+export interface ZamaConfigViem extends ZamaConfigBase {

• // (undocumented)
• ethers?: never;
• // (undocumented)
• relayer?: never;
• // (undocumented)
• signer?: never;
• // (undocumented)
• transports: Record<number, TransportConfig>;
• // (undocumented)
• viem: {

•    publicClient: PublicClient;
  

•    walletClient?: WalletClient;
  

•    ethereum?: EIP1193Provider;
  

• };
  +}

+// @public
export class ZamaError extends Error {
constructor(code: ZamaErrorCode, message: string, options?: ErrorOptions);
readonly code: ZamaErrorCode;
@@ -20700,6 +20865,7 @@

// @public
export interface ZamaSDKConfig {

• chains?: readonly FheChain[];
  keypairTTL?: number;
  onEvent?: ZamaSDKEventListener;
  registryAddresses?: Record<number, Address>;

</details>

[github-actions]

Coverage Report

Status	Category	Percentage	Covered / Total
🔵	Lines	92.45% (🎯 80%)	2942 / 3182
🔵	Statements	92.49%	3021 / 3266
🔵	Functions	91.6% (🎯 80%)	928 / 1013
🔵	Branches	85.24% (🎯 80%)	1167 / 1369

File Coverage

File	Stmts	Branches	Functions	Lines	Uncovered Lines
Changed Files
packages/react-sdk/src/provider.tsx	93.75%	75%	77.77%	93.33%	88-89
packages/react-sdk/src/test-fixtures.tsx	100%	100%	100%	100%
packages/react-sdk/src/wagmi/config.ts	90%	100%	66.66%	100%	26
packages/react-sdk/src/wrappers-registry/use-wrappers-registry-address.ts	100%	100%	100%	100%
packages/sdk/src/zama-sdk.ts	95.58%	86.95%	100%	95.52%	114-115, 217, 267, 498-499
packages/sdk/src/chains/types.ts	100%	100%	100%	100%
packages/sdk/src/chains/utils.ts	100%	100%	100%	100%
packages/sdk/src/config/resolve.ts	95.08%	91.83%	100%	95%	193-199
packages/sdk/src/config/transports.ts	100%	100%	100%	100%
packages/sdk/src/config/types.ts	100%	100%	100%	100%
packages/sdk/src/credentials/session-signatures.ts	100%	100%	100%	100%
packages/sdk/src/relayer/composite-relayer.ts	68.75%	83.33%	35.71%	68.75%	50, 67-81, 89-132
packages/sdk/src/relayer/relayer-node.ts	90.9%	73.33%	96.29%	90.8%	77, 116-119, 145-146, 269-278
packages/sdk/src/relayer/relayer-utils.ts	95.65%	100%	100%	95.23%	25
packages/sdk/src/relayer/relayer-web.ts	91.8%	70.58%	96.87%	91.73%	100, 104-106, 128, 174-177, 216-217, 404-413
packages/sdk/src/worker/worker.node-client.ts	100%	100%	100%	100%

Generated in workflow #1794 for commit 07dc1fa by the Vitest Coverage Report Action