@zama-fhe/relayer-sdk 0.4.0-alpha.0 → 0.4.0-alpha.2

package/lib/node.d.ts

@@ -1,62 +1,36 @@
+import type { ApiKeyCookie } from './types/relayer';
+import type { ApiKeyHeader } from './types/relayer';
+import type { Auth } from './types/relayer';
+import type { BearerToken } from './types/relayer';
+import type { ClearValues } from './types/relayer';
+import type { ClearValueType } from './types/relayer';
 import { CompactPkeCrs } from 'node-tfhe';
-import { Eip1193Provider } from 'ethers';
-import { Prettify } from './utils/types';
+import { EncryptionBits } from './types/primitives';
+import type { EncryptionBits as EncryptionBits_2 } from '../types/primitives';
+import type { FhevmInstanceConfig } from './types/relayer';
+import type { FhevmInstanceOptions } from './types/relayer';
+import type { PublicDecryptResults } from './types/relayer';
+import type { RelayerV2InputProofOptions } from '../relayer-provider/v2/types/types';
+import type { RelayerV2InputProofOptions as RelayerV2InputProofOptions_2 } from './relayer-provider/v2/types/types';
+import type { RelayerV2PublicDecryptOptions } from './relayer-provider/v2/types/types';
+import type { RelayerV2UserDecryptOptions } from './relayer-provider/v2/types/types';
 import { TfheClientKey } from 'node-tfhe';
 import { TfheCompactPublicKey } from 'node-tfhe';
+import type { UserDecryptResults } from './types/relayer';
+import type { ZKProof } from '../types/primitives';
+import type { ZKProof as ZKProof_2 } from './types/primitives';
 
-/**
- * Custom cookie authentication
- */
-export declare type ApiKeyCookie = {
-    __type: 'ApiKeyCookie';
-    /**
-     * The cookie name. The default value is `x-api-key`.
-     */
-    cookie?: string;
-    /**
-     * The API key.
-     */
-    value: string;
-};
+export { ApiKeyCookie }
 
-/**
- * Custom header authentication
- */
-export declare type ApiKeyHeader = {
-    __type: 'ApiKeyHeader';
-    /**
-     * The header name. The default value is `x-api-key`.
-     */
-    header?: string;
-    /**
-     * The API key.
-     */
-    value: string;
-};
+export { ApiKeyHeader }
 
-/**
- * Set the authentication method for the request. The default is no authentication.
- * It supports:
- * - Bearer Token
- * - Custom header
- * - Custom cookie
- */
-export declare type Auth = BearerToken | ApiKeyHeader | ApiKeyCookie;
+export { Auth }
 
-/**
- * Bearer Token Authentication
- */
-export declare type BearerToken = {
-    __type: 'BearerToken';
-    /**
-     * The Bearer token.
-     */
-    token: string;
-};
+export { BearerToken }
 
-export declare type ClearValues = Record<`0x${string}`, ClearValueType>;
+export { ClearValues }
 
-export declare type ClearValueType = bigint | boolean | `0x${string}`;
+export { ClearValueType }
 
 /**
  * Creates an EIP712 structure specifically for user decrypt requests
@@ -102,49 +76,21 @@ export declare type EIP712Type = {
     type: string;
 };
 
-/**
- * **FHE Type Mapping for Input Builders**
- * * Maps the **number of encrypted bits** used by a FHEVM primary type
- * to its corresponding **FheTypeId**. This constant is primarily used by
- * `EncryptedInput` and `RelayerEncryptedInput` builders to determine the correct
- * input type and calculate the total required bit-length.
- *
- * **Structure: \{ Encrypted Bit Length: FheTypeId \}**
- *
- * | Bits | FheTypeId | FHE Type Name | Note |
- * | :--- | :-------- | :------------ | :--- |
- * | 2    | 0         | `ebool`         | The boolean type. |
- * | (N/A)| 1         | `euint4`        | **Deprecated** and omitted from this map. |
- * | 8    | 2         | `euint8`        | |
- * | 16   | 3         | `euint16`       | |
- * | 32   | 4         | `euint32`       | |
- * | 64   | 5         | `euint64`       | |
- * | 128  | 6         | `euint128`      | |
- * | 160  | 7         | `eaddress`      | Used for encrypted Ethereum addresses. |
- * | 256  | 8         | `euint256`      | The maximum supported integer size. |
- */
-export declare const ENCRYPTION_TYPES: {
-    2: number;
-    8: number;
-    16: number;
-    32: number;
-    64: number;
-    128: number;
-    160: number;
-    256: number;
-};
-
-export declare type EncryptionBits = keyof typeof ENCRYPTION_TYPES;
+export { EncryptionBits }
 
 export declare type FhevmInstance = {
     createEncryptedInput: (contractAddress: string, userAddress: string) => RelayerEncryptedInput;
+    requestZKProofVerification: (zkProof: ZKProof_2, options?: RelayerV2InputProofOptions_2) => Promise<{
+        handles: Uint8Array[];
+        inputProof: Uint8Array;
+    }>;
     generateKeypair: () => {
         publicKey: string;
         privateKey: string;
     };
     createEIP712: (publicKey: string, contractAddresses: string[], startTimestamp: string | number, durationDays: string | number) => EIP712;
-    publicDecrypt: (handles: (string | Uint8Array)[]) => Promise<PublicDecryptResults>;
-    userDecrypt: (handles: HandleContractPair[], privateKey: string, publicKey: string, signature: string, contractAddresses: string[], userAddress: string, startTimestamp: string | number, durationDays: string | number) => Promise<UserDecryptResults>;
+    publicDecrypt: (handles: (string | Uint8Array)[], options?: RelayerV2PublicDecryptOptions) => Promise<PublicDecryptResults>;
+    userDecrypt: (handles: HandleContractPair[], privateKey: string, publicKey: string, signature: string, contractAddresses: string[], userAddress: string, startTimestamp: string | number, durationDays: string | number, options?: RelayerV2UserDecryptOptions) => Promise<UserDecryptResults>;
     getPublicKey: () => {
         publicKeyId: string;
         publicKey: Uint8Array;
@@ -155,26 +101,9 @@ export declare type FhevmInstance = {
     } | null;
 };
 
-export declare type FhevmInstanceConfig = Prettify<{
-    verifyingContractAddressDecryption: string;
-    verifyingContractAddressInputVerification: string;
-    kmsContractAddress: string;
-    inputVerifierContractAddress: string;
-    aclContractAddress: string;
-    gatewayChainId: number;
-    chainId?: number;
-    relayerUrl?: string;
-    network?: Eip1193Provider | string;
-    publicParams?: PublicParams<Uint8Array> | null;
-    publicKey?: {
-        data: Uint8Array | null;
-        id: string | null;
-    };
-} & FhevmInstanceOptions>;
+export { FhevmInstanceConfig }
 
-export declare type FhevmInstanceOptions = {
-    auth?: Auth;
-};
+export { FhevmInstanceOptions }
 
 export declare const generateKeypair: () => {
     publicKey: string;
@@ -190,11 +119,9 @@ export declare type HandleContractPair = {
     contractAddress: string;
 };
 
-export declare type PublicDecryptResults = {
-    clearValues: ClearValues;
-    abiEncodedClearValues: `0x${string}`;
-    decryptionProof: `0x${string}`;
-};
+export declare const MainnetConfig: FhevmInstanceConfig;
+
+export { PublicDecryptResults }
 
 export declare type PublicParams<T = TFHEType['CompactPkeCrs']> = {
     2048: {
@@ -212,10 +139,9 @@ export declare type RelayerEncryptedInput = {
     add128: (value: number | bigint) => RelayerEncryptedInput;
     add256: (value: number | bigint) => RelayerEncryptedInput;
     addAddress: (value: string) => RelayerEncryptedInput;
-    getBits: () => EncryptionBits[];
-    encrypt: (options?: {
-        auth?: Auth;
-    }) => Promise<{
+    getBits: () => EncryptionBits_2[];
+    generateZKProof(): ZKProof;
+    encrypt: (options?: RelayerV2InputProofOptions) => Promise<{
         handles: Uint8Array[];
         inputProof: Uint8Array;
     }>;
@@ -234,6 +160,6 @@ export declare type TFHEType = {
     ZkComputeLoad: any;
 };
 
-export declare type UserDecryptResults = ClearValues;
+export { UserDecryptResults }
 
 export { }