@zama-fhe/relayer-sdk 0.1.0-1

package/lib/node.d.ts

@@ -0,0 +1,2 @@
+export * from '.';
+export * from './tfhe';

package/lib/relayer/decryptUtils.d.ts

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

package/lib/relayer/handles.d.ts

@@ -0,0 +1,4 @@
+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

@@ -0,0 +1,31 @@
+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

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

package/lib/relayer/publicDecrypt.d.ts

@@ -0,0 +1,3 @@
+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

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

package/lib/relayer/sendEncryption.d.ts

@@ -0,0 +1,41 @@
+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

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

package/lib/relayer/userDecrypt.d.ts

@@ -0,0 +1,11 @@
+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

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

package/lib/sdk/encrypt.d.ts

@@ -0,0 +1,34 @@
+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

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

package/lib/sdk/encryptionTypes.d.ts

@@ -0,0 +1,13 @@
+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

@@ -0,0 +1,34 @@
+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

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

package/lib/test/index.d.ts

@@ -0,0 +1,10 @@
+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

@@ -0,0 +1,7 @@
+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

@@ -0,0 +1,9 @@
+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;

package/lib/web.d.ts

@@ -0,0 +1,2 @@
+export * from '.';
+export * from './init';