@zama-fhe/sdk 1.0.0-alpha.10

package/dist/relayer-sdk.types-CgHZ6qZn.d.ts

@@ -0,0 +1,327 @@
+import * as SDK from '@zama-fhe/relayer-sdk/bundle';
+import { FhevmInstanceConfig, Address, ZKProofLike, KmsDelegatedUserDecryptEIP712Type, InputProofBytesType } from '@zama-fhe/relayer-sdk/bundle';
+
+/**
+ * Optional logger for worker client observability.
+ * Pass to `WorkerClientConfig` or `NodeWorkerClientConfig` to observe
+ * request lifecycle (start, success, error, timeout).
+ */
+interface GenericLogger {
+    info: (message: string, data?: Record<string, unknown>) => void;
+    debug: (message: string, data?: Record<string, unknown>) => void;
+    warn: (message: string, data?: Record<string, unknown>) => void;
+    error: (message: string, data?: Record<string, unknown>) => void;
+}
+type WorkerRequestType = "INIT" | "NODE_INIT" | "UPDATE_CSRF" | "ENCRYPT" | "USER_DECRYPT" | "PUBLIC_DECRYPT" | "GENERATE_KEYPAIR" | "CREATE_EIP712" | "CREATE_DELEGATED_EIP712" | "DELEGATED_USER_DECRYPT" | "REQUEST_ZK_PROOF_VERIFICATION" | "GET_PUBLIC_KEY" | "GET_PUBLIC_PARAMS";
+interface BaseRequest {
+    id: string;
+    type: WorkerRequestType;
+}
+interface InitRequest extends BaseRequest {
+    type: "INIT";
+    payload: {
+        cdnUrl: string;
+        fhevmConfig: FhevmInstanceConfig;
+        csrfToken: string;
+        /** Expected SHA-384 hex digest for integrity verification. */
+        integrity?: string;
+        /** Number of WASM threads for parallel FHE operations. */
+        thread?: number;
+    };
+}
+interface NodeInitRequest extends BaseRequest {
+    type: "NODE_INIT";
+    payload: {
+        fhevmConfig: FhevmInstanceConfig;
+    };
+}
+interface UpdateCsrfRequest extends BaseRequest {
+    type: "UPDATE_CSRF";
+    payload: {
+        csrfToken: string;
+    };
+}
+interface EncryptRequest extends BaseRequest {
+    type: "ENCRYPT";
+    payload: {
+        values: EncryptInput[];
+        contractAddress: Address;
+        userAddress: Address;
+    };
+}
+interface UserDecryptRequest extends BaseRequest {
+    type: "USER_DECRYPT";
+    payload: {
+        handles: string[];
+        contractAddress: Address;
+        signedContractAddresses: Address[];
+        privateKey: string;
+        publicKey: string;
+        signature: string;
+        signerAddress: Address;
+        startTimestamp: number;
+        durationDays: number;
+    };
+}
+interface PublicDecryptRequest extends BaseRequest {
+    type: "PUBLIC_DECRYPT";
+    payload: {
+        handles: string[];
+    };
+}
+interface GenerateKeypairRequest extends BaseRequest {
+    type: "GENERATE_KEYPAIR";
+    payload: Record<string, never>;
+}
+interface CreateEIP712Request extends BaseRequest {
+    type: "CREATE_EIP712";
+    payload: {
+        publicKey: string;
+        contractAddresses: Address[];
+        startTimestamp: number;
+        durationDays: number;
+    };
+}
+interface CreateDelegatedEIP712Request extends BaseRequest {
+    type: "CREATE_DELEGATED_EIP712";
+    payload: {
+        publicKey: string;
+        contractAddresses: Address[];
+        delegatorAddress: string;
+        startTimestamp: number;
+        durationDays: number;
+    };
+}
+interface DelegatedUserDecryptRequest extends BaseRequest {
+    type: "DELEGATED_USER_DECRYPT";
+    payload: {
+        handles: string[];
+        contractAddress: Address;
+        signedContractAddresses: Address[];
+        privateKey: string;
+        publicKey: string;
+        signature: string;
+        delegatorAddress: Address;
+        delegateAddress: Address;
+        startTimestamp: number;
+        durationDays: number;
+    };
+}
+interface RequestZKProofVerificationRequest extends BaseRequest {
+    type: "REQUEST_ZK_PROOF_VERIFICATION";
+    payload: {
+        zkProof: ZKProofLike;
+    };
+}
+interface GetPublicKeyRequest extends BaseRequest {
+    type: "GET_PUBLIC_KEY";
+    payload: Record<string, never>;
+}
+interface GetPublicParamsRequest extends BaseRequest {
+    type: "GET_PUBLIC_PARAMS";
+    payload: {
+        bits: number;
+    };
+}
+type WorkerRequest = InitRequest | NodeInitRequest | UpdateCsrfRequest | EncryptRequest | UserDecryptRequest | PublicDecryptRequest | GenerateKeypairRequest | CreateEIP712Request | CreateDelegatedEIP712Request | DelegatedUserDecryptRequest | RequestZKProofVerificationRequest | GetPublicKeyRequest | GetPublicParamsRequest;
+type EncryptPayload = EncryptRequest["payload"];
+type UserDecryptPayload = UserDecryptRequest["payload"];
+type DelegatedUserDecryptPayload = DelegatedUserDecryptRequest["payload"];
+type CreateEIP712Payload = CreateEIP712Request["payload"];
+type CreateDelegatedEIP712Payload = CreateDelegatedEIP712Request["payload"];
+interface BaseResponse {
+    id: string;
+    type: WorkerRequestType;
+}
+interface SuccessResponse<T> extends BaseResponse {
+    success: true;
+    data: T;
+}
+interface ErrorResponse extends BaseResponse {
+    success: false;
+    error: string;
+    /** HTTP status code from the relayer, when available. */
+    statusCode?: number;
+}
+type WorkerResponse<T> = SuccessResponse<T> | ErrorResponse;
+interface EncryptResponseData {
+    handles: Uint8Array[];
+    inputProof: Uint8Array;
+}
+interface UserDecryptResponseData {
+    clearValues: Record<string, DecryptedValue>;
+}
+interface PublicDecryptResponseData {
+    clearValues: Record<string, bigint>;
+    abiEncodedClearValues: string;
+    decryptionProof: Address;
+}
+interface GenerateKeypairResponseData {
+    publicKey: string;
+    privateKey: string;
+}
+interface CreateEIP712ResponseData {
+    domain: {
+        name: string;
+        version: string;
+        chainId: number;
+        verifyingContract: Address;
+    };
+    types: {
+        UserDecryptRequestVerification: Array<{
+            name: string;
+            type: string;
+        }>;
+    };
+    message: {
+        publicKey: string;
+        contractAddresses: string[];
+        startTimestamp: bigint;
+        durationDays: bigint;
+        extraData: string;
+    };
+}
+type CreateDelegatedEIP712ResponseData = KmsDelegatedUserDecryptEIP712Type;
+interface DelegatedUserDecryptResponseData {
+    clearValues: Record<string, DecryptedValue>;
+}
+type RequestZKProofVerificationResponseData = InputProofBytesType;
+interface GetPublicKeyResponseData {
+    result: {
+        publicKeyId: string;
+        publicKey: Uint8Array;
+    } | null;
+}
+interface GetPublicParamsResponseData {
+    result: {
+        publicParams: Uint8Array;
+        publicParamsId: string;
+    } | null;
+}
+
+/** Generic hex-encoded string (signatures, tx hashes, proofs, etc.). */
+type Hex = `0x${string}`;
+/** Network configuration for the Relayer SDK */
+type NetworkType = "hardhat" | "sepolia" | "mainnet";
+/** Security options for RelayerWeb. */
+interface RelayerWebSecurityConfig {
+    /** Resolve the current CSRF token. Called before each authenticated network request. */
+    getCsrfToken?: () => string;
+    /** Verify SHA-384 integrity of the CDN bundle. Defaults to `true`. Set to `false` only in test environments with mocked SDK scripts. */
+    integrityCheck?: boolean;
+}
+/** Configuration for RelayerWeb (browser backend) initialization. */
+interface RelayerWebConfig {
+    transports: Record<number, Partial<SDK.FhevmInstanceConfig>>;
+    /** Resolve the current chain ID. Called lazily before each operation; the worker is re-initialized when the value changes. */
+    getChainId: () => Promise<number>;
+    /** Security options (CSRF, CDN integrity). */
+    security?: RelayerWebSecurityConfig;
+    /** Optional logger for observing worker lifecycle and request timing. */
+    logger?: GenericLogger;
+    /**
+     * Number of WASM threads for parallel FHE operations inside the Web Worker.
+     * Uses `wasm-bindgen-rayon` under the hood via `SharedArrayBuffer`.
+     *
+     * **Requirements:** The page must be served with COOP/COEP headers:
+     * - `Cross-Origin-Opener-Policy: same-origin`
+     * - `Cross-Origin-Embedder-Policy: require-corp`
+     *
+     * 4–8 threads is the practical sweet spot; beyond that, diminishing returns
+     * and higher memory usage on low-end devices.
+     *
+     * When omitted, the relayer SDK uses its default (single-threaded).
+     */
+    threads?: number;
+    /** Called whenever the SDK status changes (e.g. idle → initializing → ready). */
+    onStatusChange?: (status: RelayerSDKStatus, error?: Error) => void;
+}
+/** Result from encryption operation */
+interface EncryptResult {
+    handles: Uint8Array[];
+    inputProof: Uint8Array;
+}
+/** Supported FHE encrypted types. */
+type FheType = "ebool" | "euint8" | "euint16" | "euint32" | "euint64" | "euint128" | "euint256" | "eaddress";
+/** A single value to encrypt with its FHE type. */
+interface EncryptInput {
+    value: bigint | boolean;
+    type: FheType;
+}
+/** Parameters for encryption */
+interface EncryptParams {
+    /** Typed inputs for encryption. Each value must specify its FHE type. */
+    values: EncryptInput[];
+    contractAddress: Address;
+    userAddress: Address;
+}
+/**
+ * Union of possible decrypted value types.
+ * - bigint for euintN types
+ * - boolean for ebool
+ * - hex string for eaddress
+ */
+type DecryptedValue = bigint | boolean | `0x${string}`;
+/** Parameters for user decryption */
+interface UserDecryptParams {
+    handles: string[];
+    contractAddress: Address;
+    signedContractAddresses: Address[];
+    privateKey: string;
+    publicKey: string;
+    signature: string;
+    signerAddress: Address;
+    startTimestamp: number;
+    durationDays: number;
+}
+/** Result from public decryption */
+interface PublicDecryptResult {
+    clearValues: Record<string, bigint>;
+    abiEncodedClearValues: string;
+    decryptionProof: Address;
+}
+/** Keypair for FHE operations */
+interface FHEKeypair {
+    publicKey: string;
+    privateKey: string;
+}
+/** EIP712 typed data structure */
+interface EIP712TypedData {
+    domain: {
+        name: string;
+        version: string;
+        chainId: number;
+        verifyingContract: Address;
+    };
+    types: {
+        [key: string]: Array<{
+            name: string;
+            type: string;
+        }>;
+    };
+    primaryType?: string;
+    message: {
+        publicKey: string;
+        contractAddresses: string[];
+        startTimestamp: bigint;
+        durationDays: bigint;
+        extraData: string;
+    };
+}
+/** Parameters for delegated user decryption */
+interface DelegatedUserDecryptParams {
+    handles: string[];
+    contractAddress: Address;
+    signedContractAddresses: Address[];
+    privateKey: string;
+    publicKey: string;
+    signature: string;
+    delegatorAddress: Address;
+    delegateAddress: Address;
+    startTimestamp: number;
+    durationDays: number;
+}
+/** SDK status */
+type RelayerSDKStatus = "idle" | "initializing" | "ready" | "error";
+
+export type { PublicDecryptRequest as A, BaseRequest as B, CreateEIP712Payload as C, DecryptedValue as D, EIP712TypedData as E, FHEKeypair as F, GenericLogger as G, Hex as H, InitRequest as I, RequestZKProofVerificationRequest as J, UpdateCsrfRequest as K, UserDecryptRequest as L, RelayerWebConfig as M, NodeInitRequest as N, RelayerSDKStatus as O, PublicDecryptResult as P, EncryptInput as Q, RequestZKProofVerificationResponseData as R, SuccessResponse as S, FheType as T, UserDecryptParams as U, NetworkType as V, WorkerRequest as W, RelayerWebSecurityConfig as X, EncryptParams as a, EncryptResult as b, DelegatedUserDecryptParams as c, WorkerRequestType as d, WorkerResponse as e, GenerateKeypairResponseData as f, CreateEIP712ResponseData as g, EncryptPayload as h, EncryptResponseData as i, UserDecryptPayload as j, UserDecryptResponseData as k, PublicDecryptResponseData as l, CreateDelegatedEIP712Payload as m, CreateDelegatedEIP712ResponseData as n, DelegatedUserDecryptPayload as o, DelegatedUserDecryptResponseData as p, GetPublicKeyResponseData as q, GetPublicParamsResponseData as r, CreateDelegatedEIP712Request as s, CreateEIP712Request as t, DelegatedUserDecryptRequest as u, EncryptRequest as v, ErrorResponse as w, GenerateKeypairRequest as x, GetPublicKeyRequest as y, GetPublicParamsRequest as z };