@pyratzlabs/react-fhevm-utils 1.1.2 → 2.0.1

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/bundle";
 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 type { HandleContractPair } from "@zama-fhe/relayer-sdk/bundle";
+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").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").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").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").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").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").DecryptedResults, Error, HandleContractPair[], unknown>;
 } | {
-    data: bigint;
+    data: import("@zama-fhe/relayer-sdk").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").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").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/useFhevmInstance.d.ts

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

package/dist/hooks/useGetEncryptedBalance.d.ts

@@ -4,5 +4,5 @@ export interface GetEncryptedBalanceParams {
     userAddress?: Address;
 }
 export declare const useGetEncryptedBalance: ({ tokenAddress, userAddress, }: GetEncryptedBalanceParams) => {
-    encryptedBalance: bigint | undefined;
+    encryptedBalance: Address | undefined;
 };

package/dist/hooks/useGetEncryptedBalance.js

@@ -5,7 +5,7 @@ export const useGetEncryptedBalance = ({ tokenAddress, userAddress, }) => {
     const { data } = useReadContract({
         address: tokenAddress,
         abi: encryptedABI,
-        functionName: "balanceOf",
+        functionName: "confidentialBalanceOf",
         args: [userAddress !== null && userAddress !== void 0 ? userAddress : address],
         query: {
             enabled: !!address,

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 type { createInstance, FhevmInstance, SepoliaConfig, initSDK } from "@zama-fhe/relayer-sdk/bundle";
+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,16 @@ 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;
 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 window.relayerSDK.initSDK();
+        if (config) {
+            fhevmInstance = yield window.relayerSDK.createInstance(Object.assign({}, window.relayerSDK.SepoliaConfig));
+        }
+        else {
+            fhevmInstance = yield window.relayerSDK.createInstance(window.relayerSDK.SepoliaConfig);
+        }
     }
     return fhevmInstance;
 });