@pyratzlabs/react-fhevm-utils 1.1.1 → 2.0.0

package/dist/context/FhevmProvider.d.ts

@@ -1,6 +1,6 @@
 import React, { ReactNode } from "react";
-import { FhevmInstance } from "fhevmjs";
 import { FhevmConfig } from "../types/fhevmConfig";
+import { FhevmInstance } from "@zama-fhe/relayer-sdk/web";
 interface ProviderProps {
     children: ReactNode;
     config?: FhevmConfig;

package/dist/hooks/{useDecryptBalance.d.ts → useDecryptHandles.d.ts}

@@ -1,8 +1,5 @@
-import { Address } from "viem";
-export interface DecryptBalanceParams {
-    tokenAddress: Address;
-}
-export declare const useDecryptBalance: ({ tokenAddress }: DecryptBalanceParams) => {
+import { HandleContractPair } from "@zama-fhe/relayer-sdk/web";
+export declare const useDecryptHandles: () => {
     data: undefined;
     variables: undefined;
     error: null;
@@ -11,63 +8,63 @@ export declare const useDecryptBalance: ({ tokenAddress }: DecryptBalanceParams)
     isPending: false;
     isSuccess: false;
     status: "idle";
-    mutate: import("@tanstack/react-query").UseMutateFunction<bigint, Error, bigint, unknown>;
+    mutate: import("@tanstack/react-query").UseMutateFunction<import("@zama-fhe/relayer-sdk/web").DecryptedResults, Error, HandleContractPair[], unknown>;
     reset: () => void;
     context: unknown;
     failureCount: number;
     failureReason: Error | null;
     isPaused: boolean;
     submittedAt: number;
-    mutateAsync: import("@tanstack/react-query").UseMutateAsyncFunction<bigint, Error, bigint, unknown>;
+    mutateAsync: import("@tanstack/react-query").UseMutateAsyncFunction<import("@zama-fhe/relayer-sdk/web").DecryptedResults, Error, HandleContractPair[], unknown>;
 } | {
     data: undefined;
-    variables: bigint;
+    variables: HandleContractPair[];
     error: null;
     isError: false;
     isIdle: false;
     isPending: true;
     isSuccess: false;
     status: "pending";
-    mutate: import("@tanstack/react-query").UseMutateFunction<bigint, Error, bigint, unknown>;
+    mutate: import("@tanstack/react-query").UseMutateFunction<import("@zama-fhe/relayer-sdk/web").DecryptedResults, Error, HandleContractPair[], unknown>;
     reset: () => void;
     context: unknown;
     failureCount: number;
     failureReason: Error | null;
     isPaused: boolean;
     submittedAt: number;
-    mutateAsync: import("@tanstack/react-query").UseMutateAsyncFunction<bigint, Error, bigint, unknown>;
+    mutateAsync: import("@tanstack/react-query").UseMutateAsyncFunction<import("@zama-fhe/relayer-sdk/web").DecryptedResults, Error, HandleContractPair[], unknown>;
 } | {
     data: undefined;
     error: Error;
-    variables: bigint;
+    variables: HandleContractPair[];
     isError: true;
     isIdle: false;
     isPending: false;
     isSuccess: false;
     status: "error";
-    mutate: import("@tanstack/react-query").UseMutateFunction<bigint, Error, bigint, unknown>;
+    mutate: import("@tanstack/react-query").UseMutateFunction<import("@zama-fhe/relayer-sdk/web").DecryptedResults, Error, HandleContractPair[], unknown>;
     reset: () => void;
     context: unknown;
     failureCount: number;
     failureReason: Error | null;
     isPaused: boolean;
     submittedAt: number;
-    mutateAsync: import("@tanstack/react-query").UseMutateAsyncFunction<bigint, Error, bigint, unknown>;
+    mutateAsync: import("@tanstack/react-query").UseMutateAsyncFunction<import("@zama-fhe/relayer-sdk/web").DecryptedResults, Error, HandleContractPair[], unknown>;
 } | {
-    data: bigint;
+    data: import("@zama-fhe/relayer-sdk/web").DecryptedResults;
     error: null;
-    variables: bigint;
+    variables: HandleContractPair[];
     isError: false;
     isIdle: false;
     isPending: false;
     isSuccess: true;
     status: "success";
-    mutate: import("@tanstack/react-query").UseMutateFunction<bigint, Error, bigint, unknown>;
+    mutate: import("@tanstack/react-query").UseMutateFunction<import("@zama-fhe/relayer-sdk/web").DecryptedResults, Error, HandleContractPair[], unknown>;
     reset: () => void;
     context: unknown;
     failureCount: number;
     failureReason: Error | null;
     isPaused: boolean;
     submittedAt: number;
-    mutateAsync: import("@tanstack/react-query").UseMutateAsyncFunction<bigint, Error, bigint, unknown>;
+    mutateAsync: import("@tanstack/react-query").UseMutateAsyncFunction<import("@zama-fhe/relayer-sdk/web").DecryptedResults, Error, HandleContractPair[], unknown>;
 };

package/dist/hooks/{useDecryptBalance.js → useDecryptHandles.js}

@@ -10,25 +10,30 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 import { useMutation } from "@tanstack/react-query";
 import { useAccount, useSignTypedData } from "wagmi";
 import { useFhevmContext } from "../context/FhevmProvider";
-export const useDecryptBalance = ({ tokenAddress }) => {
+export const useDecryptHandles = () => {
     const { instance } = useFhevmContext();
     const { address } = useAccount();
     const { signTypedDataAsync } = useSignTypedData();
     const decryptMutation = useMutation({
-        mutationFn: (encryptedBalance) => __awaiter(void 0, void 0, void 0, function* () {
+        mutationFn: (handles) => __awaiter(void 0, void 0, void 0, function* () {
             if (!instance)
                 throw new Error("Instance is not defined");
             if (!address)
                 throw new Error("User wallet is not connected");
+            const startTimeStamp = Math.floor(Date.now() / 1000).toString();
+            const durationDays = "1";
             const { publicKey, privateKey } = instance.generateKeypair();
-            const eip712 = instance.createEIP712(publicKey, tokenAddress);
+            const contractAddresses = handles.map((handle) => handle.contractAddress);
+            const eip712 = instance.createEIP712(publicKey, contractAddresses, startTimeStamp, durationDays);
             const signature = yield signTypedDataAsync({
                 domain: eip712.domain,
-                types: { Reencrypt: eip712.types.Reencrypt },
-                primaryType: "Reencrypt",
+                types: {
+                    UserDecryptRequestVerification: eip712.types.UserDecryptRequestVerification,
+                },
+                primaryType: "UserDecryptRequestVerification",
                 message: eip712.message,
             });
-            const decryptedBalance = yield instance.reencrypt(encryptedBalance, privateKey, publicKey, signature.replace("0x", ""), tokenAddress, address);
+            const decryptedBalance = yield instance.userDecrypt(handles, privateKey, publicKey, signature.replace("0x", ""), contractAddresses, address, startTimeStamp, durationDays);
             return decryptedBalance;
         }),
     });

package/dist/hooks/useEncryptValue.d.ts

@@ -15,14 +15,20 @@ export declare const useEncryptValue: ({ tokenAddress }: EncryptValueParams) =>
     isPending: false;
     isSuccess: false;
     status: "idle";
-    mutate: import("@tanstack/react-query").UseMutateFunction<EncryptionResult, Error, bigint, unknown>;
+    mutate: import("@tanstack/react-query").UseMutateFunction<{
+        handles: Uint8Array[];
+        inputProof: Uint8Array;
+    }, Error, bigint, unknown>;
     reset: () => void;
     context: unknown;
     failureCount: number;
     failureReason: Error | null;
     isPaused: boolean;
     submittedAt: number;
-    mutateAsync: import("@tanstack/react-query").UseMutateAsyncFunction<EncryptionResult, Error, bigint, unknown>;
+    mutateAsync: import("@tanstack/react-query").UseMutateAsyncFunction<{
+        handles: Uint8Array[];
+        inputProof: Uint8Array;
+    }, Error, bigint, unknown>;
 } | {
     data: undefined;
     variables: bigint;
@@ -32,14 +38,20 @@ export declare const useEncryptValue: ({ tokenAddress }: EncryptValueParams) =>
     isPending: true;
     isSuccess: false;
     status: "pending";
-    mutate: import("@tanstack/react-query").UseMutateFunction<EncryptionResult, Error, bigint, unknown>;
+    mutate: import("@tanstack/react-query").UseMutateFunction<{
+        handles: Uint8Array[];
+        inputProof: Uint8Array;
+    }, Error, bigint, unknown>;
     reset: () => void;
     context: unknown;
     failureCount: number;
     failureReason: Error | null;
     isPaused: boolean;
     submittedAt: number;
-    mutateAsync: import("@tanstack/react-query").UseMutateAsyncFunction<EncryptionResult, Error, bigint, unknown>;
+    mutateAsync: import("@tanstack/react-query").UseMutateAsyncFunction<{
+        handles: Uint8Array[];
+        inputProof: Uint8Array;
+    }, Error, bigint, unknown>;
 } | {
     data: undefined;
     error: Error;
@@ -49,16 +61,25 @@ export declare const useEncryptValue: ({ tokenAddress }: EncryptValueParams) =>
     isPending: false;
     isSuccess: false;
     status: "error";
-    mutate: import("@tanstack/react-query").UseMutateFunction<EncryptionResult, Error, bigint, unknown>;
+    mutate: import("@tanstack/react-query").UseMutateFunction<{
+        handles: Uint8Array[];
+        inputProof: Uint8Array;
+    }, Error, bigint, unknown>;
     reset: () => void;
     context: unknown;
     failureCount: number;
     failureReason: Error | null;
     isPaused: boolean;
     submittedAt: number;
-    mutateAsync: import("@tanstack/react-query").UseMutateAsyncFunction<EncryptionResult, Error, bigint, unknown>;
+    mutateAsync: import("@tanstack/react-query").UseMutateAsyncFunction<{
+        handles: Uint8Array[];
+        inputProof: Uint8Array;
+    }, Error, bigint, unknown>;
 } | {
-    data: EncryptionResult;
+    data: {
+        handles: Uint8Array[];
+        inputProof: Uint8Array;
+    };
     error: null;
     variables: bigint;
     isError: false;
@@ -66,12 +87,18 @@ export declare const useEncryptValue: ({ tokenAddress }: EncryptValueParams) =>
     isPending: false;
     isSuccess: true;
     status: "success";
-    mutate: import("@tanstack/react-query").UseMutateFunction<EncryptionResult, Error, bigint, unknown>;
+    mutate: import("@tanstack/react-query").UseMutateFunction<{
+        handles: Uint8Array[];
+        inputProof: Uint8Array;
+    }, Error, bigint, unknown>;
     reset: () => void;
     context: unknown;
     failureCount: number;
     failureReason: Error | null;
     isPaused: boolean;
     submittedAt: number;
-    mutateAsync: import("@tanstack/react-query").UseMutateAsyncFunction<EncryptionResult, Error, bigint, unknown>;
+    mutateAsync: import("@tanstack/react-query").UseMutateAsyncFunction<{
+        handles: Uint8Array[];
+        inputProof: Uint8Array;
+    }, Error, bigint, unknown>;
 };

package/dist/hooks/useEncryptValue.js

@@ -8,42 +8,22 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 import { useMutation } from "@tanstack/react-query";
-import { useEffect, useRef } from "react";
 import { useAccount } from "wagmi";
 import { useFhevmContext } from "../context/FhevmProvider";
+import { encryptInt64 } from "../workers/encryption.worker";
 export const useEncryptValue = ({ tokenAddress }) => {
     const { instance, config } = useFhevmContext();
     const { address } = useAccount();
-    const workerRef = useRef(null);
-    useEffect(() => {
-        workerRef.current = new Worker(new URL("../workers/encryption.worker", import.meta.url), { type: "module" });
-        return () => {
-            var _a;
-            (_a = workerRef.current) === null || _a === void 0 ? void 0 : _a.terminate();
-        };
-    }, []);
     const encryptMutation = useMutation({
         mutationFn: (value) => __awaiter(void 0, void 0, void 0, function* () {
             if (!instance)
                 throw new Error("Instance is not defined");
             if (!address)
                 throw new Error("User is not connected");
-            const encryption = new Promise((resolve, reject) => {
-                if (!workerRef.current)
-                    return reject("Worker not initialized");
-                workerRef.current.onmessage = (event) => {
-                    if (event.data.error) {
-                        reject(event.data.error);
-                    }
-                    else {
-                        resolve(event.data.result);
-                    }
-                };
-                workerRef.current.postMessage(Object.assign({ tokenAddress,
-                    address,
-                    value }, config));
-            });
-            return encryption;
+            return yield encryptInt64(Object.assign({ tokenAddress,
+                address,
+                value,
+                instance }, config));
         }),
     });
     return Object.assign({}, encryptMutation);

package/dist/hooks/useFhevmInstance.d.ts

@@ -1,3 +1,3 @@
 export declare const useFhevmInstance: () => {
-    instance: import("fhevmjs").FhevmInstance | undefined;
+    instance: import("@zama-fhe/relayer-sdk/web").FhevmInstance | undefined;
 };

package/dist/hooks/useGetEncryptedBalance.d.ts

@@ -1,7 +1,8 @@
 import { Address } from "viem";
 export interface GetEncryptedBalanceParams {
     tokenAddress: Address;
+    userAddress?: Address;
 }
-export declare const useGetEncryptedBalance: ({ tokenAddress, }: GetEncryptedBalanceParams) => {
+export declare const useGetEncryptedBalance: ({ tokenAddress, userAddress, }: GetEncryptedBalanceParams) => {
     encryptedBalance: bigint | undefined;
 };

package/dist/hooks/useGetEncryptedBalance.js

@@ -1,12 +1,12 @@
 import { useAccount, useReadContract } from "wagmi";
 import { encryptedABI } from "../types/encryptedABI";
-export const useGetEncryptedBalance = ({ tokenAddress, }) => {
+export const useGetEncryptedBalance = ({ tokenAddress, userAddress, }) => {
     const { address } = useAccount();
     const { data } = useReadContract({
         address: tokenAddress,
         abi: encryptedABI,
         functionName: "balanceOf",
-        args: [address],
+        args: [userAddress !== null && userAddress !== void 0 ? userAddress : address],
         query: {
             enabled: !!address,
             refetchInterval: 5000,

package/dist/index.d.ts

@@ -1,6 +1,6 @@
 export { default } from "./context/FhevmProvider";
 export { useFhevmInstance } from "./hooks/useFhevmInstance";
-export { useDecryptBalance } from "./hooks/useDecryptBalance";
+export { useDecryptHandles } from "./hooks/useDecryptHandles";
 export { useGetEncryptedBalance } from "./hooks/useGetEncryptedBalance";
 export { useEncryptedTransfer } from "./hooks/useEncryptedTransfer";
 export { useEncryptValue } from "./hooks/useEncryptValue";

package/dist/index.js

@@ -2,7 +2,7 @@
 export { default } from "./context/FhevmProvider";
 // hooks
 export { useFhevmInstance } from "./hooks/useFhevmInstance";
-export { useDecryptBalance } from "./hooks/useDecryptBalance";
+export { useDecryptHandles } from "./hooks/useDecryptHandles";
 export { useGetEncryptedBalance } from "./hooks/useGetEncryptedBalance";
 export { useEncryptedTransfer } from "./hooks/useEncryptedTransfer";
 export { useEncryptValue } from "./hooks/useEncryptValue";

package/dist/lib/fhevm.d.ts

@@ -1,5 +1,14 @@
-import { FhevmInstance } from "fhevmjs";
 import { FhevmConfig } from "../types/fhevmConfig";
+import { createInstance, FhevmInstance, SepoliaConfig, initSDK } from "@zama-fhe/relayer-sdk/web";
+declare global {
+    interface Window {
+        relayerSDK: {
+            initSDK: typeof initSDK;
+            createInstance: typeof createInstance;
+            SepoliaConfig: typeof SepoliaConfig;
+        };
+    }
+}
 export declare const createFhevmInstance: (config?: FhevmConfig) => Promise<FhevmInstance>;
 export declare const getOrCreateFhevmInstance: (config?: FhevmConfig) => Promise<FhevmInstance>;
 export declare const getInstance: () => FhevmInstance | null;

package/dist/lib/fhevm.js

@@ -7,23 +7,17 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
-import { createInstance, initFhevm } from "fhevmjs";
-import { config } from "../config";
-import { sepolia } from "viem/chains";
-const { ACL_ADDRESS, KMS_ADDRESS, GATEWAY_URL, RPC_URL } = config;
+import { createInstance, SepoliaConfig, initSDK, } from "@zama-fhe/relayer-sdk/web";
 let fhevmInstance = null;
 export const createFhevmInstance = (config) => __awaiter(void 0, void 0, void 0, function* () {
-    var _a, _b;
     if (!fhevmInstance) {
-        yield initFhevm();
-        fhevmInstance = yield createInstance({
-            chainId: (_a = config === null || config === void 0 ? void 0 : config.chainId) !== null && _a !== void 0 ? _a : sepolia.id,
-            networkUrl: (_b = config === null || config === void 0 ? void 0 : config.networkUrl) !== null && _b !== void 0 ? _b : RPC_URL,
-            network: config === null || config === void 0 ? void 0 : config.network,
-            gatewayUrl: GATEWAY_URL,
-            aclContractAddress: ACL_ADDRESS,
-            kmsContractAddress: KMS_ADDRESS,
-        });
+        yield initSDK();
+        if (config) {
+            fhevmInstance = yield createInstance(Object.assign({}, SepoliaConfig));
+        }
+        else {
+            fhevmInstance = yield createInstance(SepoliaConfig);
+        }
     }
     return fhevmInstance;
 });

package/dist/workers/encryption.worker.d.ts

@@ -1 +1,12 @@
+import { FhevmInstance } from "@zama-fhe/relayer-sdk/web";
+interface EventData {
+    tokenAddress: string;
+    address?: string;
+    value: bigint;
+    instance: FhevmInstance;
+}
+export declare const encryptInt64: (data: EventData) => Promise<{
+    handles: Uint8Array[];
+    inputProof: Uint8Array;
+}>;
 export {};

package/dist/workers/encryption.worker.js

@@ -8,28 +8,13 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
-import { getOrCreateFhevmInstance } from "../lib/fhevm";
-const ctx = self;
-ctx.onmessage = (event) => __awaiter(void 0, void 0, void 0, function* () {
-    const { tokenAddress, address, value, chainId, networkUrl, network } = event.data;
-    const instance = yield getOrCreateFhevmInstance({
-        chainId,
-        network,
-        networkUrl,
-    });
+export const encryptInt64 = (data) => __awaiter(void 0, void 0, void 0, function* () {
+    const { tokenAddress, address, value, instance } = data;
     if (!instance || !address) {
-        ctx.postMessage({ error: "Instance or address is undefined" });
-        return;
-    }
-    try {
-        const result = yield instance
-            .createEncryptedInput(tokenAddress, address)
-            .add256(value)
-            .encrypt();
-        ctx.postMessage({ result });
-    }
-    catch (error) {
-        console.error("Worker error", error);
-        ctx.postMessage({ error });
+        throw new Error("Instance or address is undefined");
     }
+    return yield instance
+        .createEncryptedInput(tokenAddress, address)
+        .add64(value)
+        .encrypt();
 });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pyratzlabs/react-fhevm-utils",
-  "version": "1.1.1",
+  "version": "2.0.0",
   "description": "React hooks and utilities for Fhevmjs",
   "main": "dist/index.js",
   "files": [
@@ -31,7 +31,7 @@
   },
   "dependencies": {
     "@tanstack/react-query": "^5.71.5",
-    "fhevmjs": "^0.6.2",
+    "@zama-fhe/relayer-sdk": "^0.1.2",
     "react": "^19.1.0",
     "viem": "^2.25.0",
     "wagmi": "^2.14.16"