@zama-fhe/relayer-sdk 0.1.0-1 → 0.1.0-3

package/lib/web.d.ts

@@ -1,2 +1,141 @@
-export * from '.';
-export * from './init';
+import { CompactPkeCrs } from 'node-tfhe';
+import { Eip1193Provider } from 'ethers';
+import { InitInput as KMSInput } from 'tkms';
+import { InitInput as TFHEInput } from 'tfhe';
+
+/**
+ * Creates an EIP712 structure specifically for user decrypt requests
+ *
+ * @param gatewayChainId - The chain ID of the gateway
+ * @param verifyingContract - The address of the contract that will verify the signature
+ * @param publicKey - The user's public key as a hex string or Uint8Array
+ * @param contractAddresses - Array of contract addresses that can access the decryption
+ * @param contractsChainId - The chain ID where the contracts are deployed
+ * @param startTimestamp - The timestamp when the decryption permission becomes valid
+ * @param durationDays - How many days the decryption permission remains valid
+ * @returns EIP712 typed data structure for user decryption
+ */
+export declare const createEIP712: (gatewayChainId: number, verifyingContract: string, contractsChainId: number) => (publicKey: string | Uint8Array, contractAddresses: string[], startTimestamp: string | number, durationDays: string | number, delegatedAccount?: string) => EIP712;
+
+export declare const createInstance: (config: FhevmInstanceConfig) => Promise<FhevmInstance>;
+
+export declare type DecryptedResults = Record<string, bigint | boolean | string>;
+
+export declare type EIP712 = {
+    domain: {
+        chainId: number;
+        name: string;
+        verifyingContract: string;
+        version: string;
+    };
+    message: any;
+    primaryType: string;
+    types: {
+        [key: string]: EIP712Type[];
+    };
+};
+
+export declare type EIP712Type = {
+    name: string;
+    type: string;
+};
+
+export declare const ENCRYPTION_TYPES: {
+    1: number;
+    8: number;
+    16: number;
+    32: number;
+    64: number;
+    128: number;
+    160: number;
+    256: number;
+    512: number;
+    1024: number;
+    2048: number;
+};
+
+export declare type EncryptionTypes = keyof typeof ENCRYPTION_TYPES;
+
+export declare type FhevmInstance = {
+    createEncryptedInput: (contractAddress: string, userAddress: string) => RelayerEncryptedInput;
+    generateKeypair: () => {
+        publicKey: string;
+        privateKey: string;
+    };
+    createEIP712: (publicKey: string, contractAddresses: string[], startTimestamp: string | number, durationDays: string | number) => EIP712;
+    publicDecrypt: (handles: (string | Uint8Array)[]) => Promise<DecryptedResults>;
+    userDecrypt: (handles: HandleContractPair[], privateKey: string, publicKey: string, signature: string, contractAddresses: string[], userAddress: string, startTimestamp: string | number, durationDays: string | number) => Promise<DecryptedResults>;
+    getPublicKey: () => {
+        publicKeyId: string;
+        publicKey: Uint8Array;
+    } | null;
+    getPublicParams: (bits: keyof PublicParams) => {
+        publicParams: Uint8Array;
+        publicParamsId: string;
+    } | null;
+};
+
+declare type FhevmInstanceConfig = {
+    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;
+    };
+};
+
+export declare const generateKeypair: () => {
+    publicKey: string;
+    privateKey: string;
+};
+
+export declare type HandleContractPair = {
+    handle: Uint8Array | string;
+    contractAddress: string;
+};
+
+export declare const initFhevm: ({ tfheParams, kmsParams, thread, }?: {
+    tfheParams?: TFHEInput;
+    kmsParams?: KMSInput;
+    thread?: number;
+}) => Promise<boolean>;
+
+export { KMSInput }
+
+export declare type PublicParams<T = CompactPkeCrs> = {
+    [key in EncryptionTypes]?: {
+        publicParams: T;
+        publicParamsId: string;
+    };
+};
+
+export declare type RelayerEncryptedInput = {
+    addBool: (value: boolean | number | bigint) => RelayerEncryptedInput;
+    add8: (value: number | bigint) => RelayerEncryptedInput;
+    add16: (value: number | bigint) => RelayerEncryptedInput;
+    add32: (value: number | bigint) => RelayerEncryptedInput;
+    add64: (value: number | bigint) => RelayerEncryptedInput;
+    add128: (value: number | bigint) => RelayerEncryptedInput;
+    add256: (value: number | bigint) => RelayerEncryptedInput;
+    addBytes64: (value: Uint8Array) => RelayerEncryptedInput;
+    addBytes128: (value: Uint8Array) => RelayerEncryptedInput;
+    addBytes256: (value: Uint8Array) => RelayerEncryptedInput;
+    addAddress: (value: string) => RelayerEncryptedInput;
+    getBits: () => EncryptionTypes[];
+    encrypt: () => Promise<{
+        handles: Uint8Array[];
+        inputProof: Uint8Array;
+    }>;
+};
+
+export { TFHEInput }
+
+export { }

package/lib/web.js

@@ -27126,13 +27126,13 @@ const publicDecryptRequest = (kmsSigners, thresholdSigners, gatewayChainId, veri
 /**
  * Creates an EIP712 structure specifically for user decrypt requests
  *
- * @param gatewayChainId The chain ID of the gateway
- * @param verifyingContract The address of the contract that will verify the signature
- * @param publicKey The user's public key as a hex string or Uint8Array
- * @param contractAddresses Array of contract addresses that can access the decryption
- * @param contractsChainId The chain ID where the contracts are deployed
- * @param startTimestamp The timestamp when the decryption permission becomes valid
- * @param durationDays How many days the decryption permission remains valid
+ * @param gatewayChainId - The chain ID of the gateway
+ * @param verifyingContract - The address of the contract that will verify the signature
+ * @param publicKey - The user's public key as a hex string or Uint8Array
+ * @param contractAddresses - Array of contract addresses that can access the decryption
+ * @param contractsChainId - The chain ID where the contracts are deployed
+ * @param startTimestamp - The timestamp when the decryption permission becomes valid
+ * @param durationDays - How many days the decryption permission remains valid
  * @returns EIP712 typed data structure for user decryption
  */
 const createEIP712 = (gatewayChainId, verifyingContract, contractsChainId) => (publicKey, contractAddresses, startTimestamp, durationDays, delegatedAccount) => {
@@ -27302,4 +27302,4 @@ const initFhevm = async ({ tfheParams, kmsParams, thread, } = {}) => {
     return true;
 };
 
-export { createEIP712, createInstance, generateKeypair, initFhevm };
+export { ENCRYPTION_TYPES, createEIP712, createInstance, generateKeypair, initFhevm };

package/package.json

@@ -1,9 +1,9 @@
 {
   "name": "@zama-fhe/relayer-sdk",
-  "version": "0.1.0-1",
+  "version": "0.1.0-3",
   "description": "fhevm Relayer SDK",
   "main": "lib/node.js",
-  "types": "lib/node/node.d.ts",
+  "types": "lib/node.d.ts",
   "browser": "lib/web.js",
   "type": "module",
   "bin": {
@@ -23,6 +23,7 @@
       "require": "./bundle.js"
     },
     "./node": {
+      "import": "./lib/node.js",
       "require": "./lib/node.cjs"
     }
   },
@@ -33,12 +34,18 @@
     "lint": "eslint src/",
     "generateKeys": "./generateKeys.js",
     "build": "npm run build:lib && npm run build:bundle",
-    "build:lib": "rollup -c config/rollup.config.js",
+    "build:lib": "npm run rollup:lib && npm run build:dts",
     "build:bundle": "vite build --config config/vite.config.js",
     "test": "jest --colors --passWithNoTests --coverage",
     "test:watch": "jest --colors --passWithNoTests --watch",
     "prettier": "prettier --write \"**/*.{js,json,md,sol,ts,yml}\"",
-    "prettier:check": "prettier --check \"**/*.{js,json,md,sol,ts,yml}\""
+    "prettier:check": "prettier --check \"**/*.{js,json,md,sol,ts,yml}\"",
+    "rollup:lib": "rollup -c config/rollup.config.js",
+    "clean": "rm -rf dist.tmp lib bundle coverage",
+    "clean:dts": "rm -rf dist.tmp",
+    "tsc:dts": "tsc --project config/tsconfig.dts.json",
+    "flatten:dts": "api-extractor run --local --config config/api-extractor.node.json && api-extractor run --local --config config/api-extractor.web.json",
+    "build:dts": "npm run clean:dts && npm run tsc:dts && npm run flatten:dts && npm run clean:dts"
   },
   "repository": {
     "type": "git",
@@ -56,14 +63,15 @@
     "fetch-retry": "^6.0.0",
     "keccak": "^3.0.4",
     "node-tfhe": "^1.1.2",
-    "node-tkms": "0.11.0-rc13",
+    "node-tkms": "0.11.0-rc15",
     "tfhe": "^1.1.2",
-    "tkms": "0.11.0-rc13",
+    "tkms": "0.11.0-rc15",
     "wasm-feature-detect": "^1.8.0"
   },
   "devDependencies": {
     "@fetch-mock/jest": "^0.1.0",
     "@jest/globals": "^29.7.0",
+    "@microsoft/api-extractor": "^7.52.8",
     "@rollup/plugin-alias": "^5.1.0",
     "@rollup/plugin-commonjs": "^25.0.0",
     "@rollup/plugin-json": "^6.1.0",

package/lib/config.d.ts

@@ -1,30 +0,0 @@
-import { BrowserProvider, Eip1193Provider, JsonRpcProvider, Provider } from 'ethers';
-import { PublicParams } from './sdk/encrypt';
-import { TfheCompactPublicKey } from 'node-tfhe';
-export type FhevmInstanceConfig = {
-    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;
-    };
-};
-export declare const getProvider: (config: FhevmInstanceConfig) => JsonRpcProvider | BrowserProvider;
-export declare const getChainId: (provider: Provider, config: FhevmInstanceConfig) => Promise<number>;
-export declare const getTfheCompactPublicKey: (config: FhevmInstanceConfig) => Promise<{
-    publicKey: TfheCompactPublicKey;
-    publicKeyId: string;
-}>;
-export declare const getPublicParams: (config: FhevmInstanceConfig) => Promise<PublicParams>;
-export declare const getKMSSigners: (provider: Provider, config: FhevmInstanceConfig) => Promise<string[]>;
-export declare const getKMSSignersThreshold: (provider: Provider, config: FhevmInstanceConfig) => Promise<number>;
-export declare const getCoprocessorSigners: (provider: Provider, config: FhevmInstanceConfig) => Promise<string[]>;
-export declare const getCoprocessorSignersThreshold: (provider: Provider, config: FhevmInstanceConfig) => Promise<number>;

package/lib/index.d.ts

@@ -1,29 +0,0 @@
-import { FhevmInstanceConfig } from './config';
-import { HandleContractPair } from './relayer/userDecrypt';
-import { RelayerEncryptedInput } from './relayer/sendEncryption';
-import { DecryptedResults } from './relayer/decryptUtils';
-import { PublicParams } from './sdk/encrypt';
-import { EIP712 } from './sdk/keypair';
-export { generateKeypair, createEIP712, EIP712, EIP712Type, } from './sdk/keypair';
-export { RelayerEncryptedInput } from './relayer/sendEncryption';
-export { HandleContractPair } from './relayer/userDecrypt';
-export { PublicParams } from './sdk/encrypt';
-export type FhevmInstance = {
-    createEncryptedInput: (contractAddress: string, userAddress: string) => RelayerEncryptedInput;
-    generateKeypair: () => {
-        publicKey: string;
-        privateKey: string;
-    };
-    createEIP712: (publicKey: string, contractAddresses: string[], startTimestamp: string | number, durationDays: string | number) => EIP712;
-    publicDecrypt: (handles: (string | Uint8Array)[]) => Promise<DecryptedResults>;
-    userDecrypt: (handles: HandleContractPair[], privateKey: string, publicKey: string, signature: string, contractAddresses: string[], userAddress: string, startTimestamp: string | number, durationDays: string | number) => Promise<DecryptedResults>;
-    getPublicKey: () => {
-        publicKeyId: string;
-        publicKey: Uint8Array;
-    } | null;
-    getPublicParams: (bits: keyof PublicParams) => {
-        publicParams: Uint8Array;
-        publicParamsId: string;
-    } | null;
-};
-export declare const createInstance: (config: FhevmInstanceConfig) => Promise<FhevmInstance>;

package/lib/init.d.ts

@@ -1,7 +0,0 @@
-import { InitInput as TFHEInput } from 'tfhe';
-import { InitInput as KMSInput } from 'tkms';
-export declare const initFhevm: ({ tfheParams, kmsParams, thread, }?: {
-    tfheParams?: TFHEInput;
-    kmsParams?: KMSInput;
-    thread?: number;
-}) => Promise<boolean>;

package/lib/relayer/decryptUtils.d.ts

@@ -1,2 +0,0 @@
-export type DecryptedResults = Record<string, bigint | boolean | string>;
-export declare function checkEncryptedBits(handles: string[]): number;

package/lib/relayer/handles.d.ts

@@ -1,4 +0,0 @@
-import { ENCRYPTION_TYPES } from '../sdk/encryptionTypes';
-type EncryptionBitwidths = keyof typeof ENCRYPTION_TYPES;
-export declare const computeHandles: (ciphertextWithZKProof: Uint8Array, bitwidths: EncryptionBitwidths[], aclContractAddress: string, chainId: number, ciphertextVersion: number) => Uint8Array<ArrayBuffer>[];
-export {};

package/lib/relayer/network.d.ts

@@ -1,31 +0,0 @@
-export type RelayerKeysItem = {
-    data_id: string;
-    param_choice: number;
-    urls: string[];
-    signatures: string[];
-};
-export type RelayerKey = {
-    data_id: string;
-    param_choice: number;
-    signatures: string[];
-    urls: string[];
-};
-export type RelayerKeys = {
-    response: {
-        fhe_key_info: {
-            fhe_public_key: RelayerKey;
-            fhe_server_key: RelayerKey;
-        }[];
-        verf_public_key: {
-            key_id: string;
-            server_id: number;
-            verf_public_key_address: string;
-            verf_public_key_url: string;
-        }[];
-        crs: {
-            [key: string]: RelayerKeysItem;
-        };
-    };
-    status: string;
-};
-export declare const getKeysFromRelayer: (url: string, publicKeyId?: string | null) => Promise<any>;

package/lib/relayer/network.test.d.ts

@@ -1 +0,0 @@
-export {};

package/lib/relayer/publicDecrypt.d.ts

@@ -1,3 +0,0 @@
-import { ethers } from 'ethers';
-import { DecryptedResults } from './decryptUtils';
-export declare const publicDecryptRequest: (kmsSigners: string[], thresholdSigners: number, gatewayChainId: number, verifyingContractAddress: string, aclContractAddress: string, relayerUrl: string, provider: ethers.JsonRpcProvider | ethers.BrowserProvider) => (_handles: (Uint8Array | string)[]) => Promise<DecryptedResults>;

package/lib/relayer/publicDecrypt.test.d.ts

@@ -1 +0,0 @@
-export {};

package/lib/relayer/sendEncryption.d.ts

@@ -1,41 +0,0 @@
-import { TfheCompactPublicKey, CompactPkeCrs } from 'node-tfhe';
-import { EncryptedInput } from '../sdk/encrypt';
-import { ENCRYPTION_TYPES } from '../sdk/encryptionTypes';
-type EncryptionTypes = keyof typeof ENCRYPTION_TYPES;
-export declare const currentCiphertextVersion: () => number;
-export type FhevmRelayerInputProofResponse = {
-    response: {
-        handles: string[];
-        signatures: string[];
-    };
-    status: string;
-};
-export type RelayerEncryptedInputInternal = RelayerEncryptedInput & {
-    _input: EncryptedInput;
-};
-export type RelayerEncryptedInput = {
-    addBool: (value: boolean | number | bigint) => RelayerEncryptedInput;
-    add8: (value: number | bigint) => RelayerEncryptedInput;
-    add16: (value: number | bigint) => RelayerEncryptedInput;
-    add32: (value: number | bigint) => RelayerEncryptedInput;
-    add64: (value: number | bigint) => RelayerEncryptedInput;
-    add128: (value: number | bigint) => RelayerEncryptedInput;
-    add256: (value: number | bigint) => RelayerEncryptedInput;
-    addBytes64: (value: Uint8Array) => RelayerEncryptedInput;
-    addBytes128: (value: Uint8Array) => RelayerEncryptedInput;
-    addBytes256: (value: Uint8Array) => RelayerEncryptedInput;
-    addAddress: (value: string) => RelayerEncryptedInput;
-    getBits: () => EncryptionTypes[];
-    encrypt: () => Promise<{
-        handles: Uint8Array[];
-        inputProof: Uint8Array;
-    }>;
-};
-export type PublicParams<T = CompactPkeCrs> = {
-    [key in EncryptionTypes]?: {
-        publicParams: T;
-        publicParamsId: string;
-    };
-};
-export declare const createRelayerEncryptedInput: (aclContractAddress: string, verifyingContractAddressInputVerification: string, chainId: number, gatewayChainId: number, relayerUrl: string, tfheCompactPublicKey: TfheCompactPublicKey, publicParams: PublicParams, coprocessorSigners: string[], thresholdCoprocessorSigners: number) => (contractAddress: string, userAddress: string) => RelayerEncryptedInputInternal;
-export {};

package/lib/relayer/sendEncryption.test.d.ts

@@ -1 +0,0 @@
-export {};

package/lib/relayer/userDecrypt.d.ts

@@ -1,11 +0,0 @@
-import { ethers } from 'ethers';
-import { DecryptedResults } from './decryptUtils';
-export type HandleContractPair = {
-    handle: Uint8Array | string;
-    contractAddress: string;
-};
-export type HandleContractPairRelayer = {
-    handle: string;
-    contractAddress: string;
-};
-export declare const userDecryptRequest: (kmsSigners: string[], gatewayChainId: number, chainId: number, verifyingContractAddress: string, aclContractAddress: string, relayerUrl: string, provider: ethers.JsonRpcProvider | ethers.BrowserProvider) => (_handles: HandleContractPair[], privateKey: string, publicKey: string, signature: string, contractAddresses: string[], userAddress: string, startTimestamp: string | number, durationDays: string | number) => Promise<DecryptedResults>;

package/lib/relayer/userDecrypt.test.d.ts

@@ -1 +0,0 @@
-export {};

package/lib/sdk/encrypt.d.ts

@@ -1,34 +0,0 @@
-import { TfheCompactPublicKey, CompactPkeCrs } from 'node-tfhe';
-import { ENCRYPTION_TYPES } from './encryptionTypes';
-type EncryptionTypes = keyof typeof ENCRYPTION_TYPES;
-export type EncryptedInput = {
-    addBool: (value: boolean | number | bigint) => EncryptedInput;
-    add8: (value: number | bigint) => EncryptedInput;
-    add16: (value: number | bigint) => EncryptedInput;
-    add32: (value: number | bigint) => EncryptedInput;
-    add64: (value: number | bigint) => EncryptedInput;
-    add128: (value: number | bigint) => EncryptedInput;
-    add256: (value: number | bigint) => EncryptedInput;
-    addBytes64: (value: Uint8Array) => EncryptedInput;
-    addBytes128: (value: Uint8Array) => EncryptedInput;
-    addBytes256: (value: Uint8Array) => EncryptedInput;
-    addAddress: (value: string) => EncryptedInput;
-    getBits: () => EncryptionTypes[];
-    encrypt: () => Uint8Array;
-};
-export type PublicParams<T = CompactPkeCrs> = {
-    [key in EncryptionTypes]?: {
-        publicParams: T;
-        publicParamsId: string;
-    };
-};
-export type EncryptInputParams = {
-    aclContractAddress: string;
-    chainId: number;
-    tfheCompactPublicKey: TfheCompactPublicKey;
-    publicParams: PublicParams;
-    contractAddress: string;
-    userAddress: string;
-};
-export declare const createEncryptedInput: ({ aclContractAddress, chainId, tfheCompactPublicKey, publicParams, contractAddress, userAddress, }: EncryptInputParams) => EncryptedInput;
-export {};

package/lib/sdk/encrypt.test.d.ts

@@ -1 +0,0 @@
-export {};

package/lib/sdk/encryptionTypes.d.ts

@@ -1,13 +0,0 @@
-export declare const ENCRYPTION_TYPES: {
-    1: number;
-    8: number;
-    16: number;
-    32: number;
-    64: number;
-    128: number;
-    160: number;
-    256: number;
-    512: number;
-    1024: number;
-    2048: number;
-};

package/lib/sdk/keypair.d.ts

@@ -1,34 +0,0 @@
-export type EIP712Type = {
-    name: string;
-    type: string;
-};
-export type EIP712 = {
-    domain: {
-        chainId: number;
-        name: string;
-        verifyingContract: string;
-        version: string;
-    };
-    message: any;
-    primaryType: string;
-    types: {
-        [key: string]: EIP712Type[];
-    };
-};
-/**
- * Creates an EIP712 structure specifically for user decrypt requests
- *
- * @param gatewayChainId The chain ID of the gateway
- * @param verifyingContract The address of the contract that will verify the signature
- * @param publicKey The user's public key as a hex string or Uint8Array
- * @param contractAddresses Array of contract addresses that can access the decryption
- * @param contractsChainId The chain ID where the contracts are deployed
- * @param startTimestamp The timestamp when the decryption permission becomes valid
- * @param durationDays How many days the decryption permission remains valid
- * @returns EIP712 typed data structure for user decryption
- */
-export declare const createEIP712: (gatewayChainId: number, verifyingContract: string, contractsChainId: number) => (publicKey: string | Uint8Array, contractAddresses: string[], startTimestamp: string | number, durationDays: string | number, delegatedAccount?: string) => EIP712;
-export declare const generateKeypair: () => {
-    publicKey: string;
-    privateKey: string;
-};

package/lib/sdk/keypair.test.d.ts

@@ -1 +0,0 @@
-export {};

package/lib/test/index.d.ts

@@ -1,10 +0,0 @@
-import { CompactPkeCrs, TfheClientKey, TfheCompactPublicKey } from 'node-tfhe';
-export declare const publicKeyId = "408d8cbaa51dece7f782fe04ba0b1c1d017b1088";
-export declare const privateKey: TfheClientKey;
-export declare const publicKey: TfheCompactPublicKey;
-export declare const publicParams: {
-    2048: {
-        publicParams: CompactPkeCrs;
-        publicParamsId: string;
-    };
-};

package/lib/tfhe.d.ts

@@ -1,7 +0,0 @@
-import { TfheCompactPublicKey, TfheClientKey, CompactPkeCrs } from 'node-tfhe';
-export declare const createTfheKeypair: () => {
-    clientKey: TfheClientKey;
-    publicKey: TfheCompactPublicKey;
-    crs: CompactPkeCrs;
-};
-export declare const createTfhePublicKey: () => string;

package/lib/utils.d.ts

@@ -1,9 +0,0 @@
-export declare const SERIALIZED_SIZE_LIMIT_CIPHERTEXT: bigint;
-export declare const SERIALIZED_SIZE_LIMIT_PK: bigint;
-export declare const SERIALIZED_SIZE_LIMIT_CRS: bigint;
-export declare const cleanURL: (url: string | undefined) => string;
-export declare const numberToHex: (num: number) => string;
-export declare const fromHexString: (hexString: string) => Uint8Array;
-export declare const toHexString: (bytes: Uint8Array, with0x?: boolean) => string;
-export declare const bytesToHex: (byteArray: Uint8Array) => string;
-export declare const bytesToBigInt: (byteArray: Uint8Array) => bigint;