@pyratzlabs/react-fhevm-utils 2.0.0 → 2.0.2

package/dist/context/FhevmProvider.d.ts

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

package/dist/hooks/useDecryptHandles.d.ts

@@ -1,4 +1,4 @@
-import { HandleContractPair } from "@zama-fhe/relayer-sdk/web";
+import type { HandleContractPair } from "@zama-fhe/relayer-sdk/bundle";
 export declare const useDecryptHandles: () => {
     data: undefined;
     variables: undefined;
@@ -8,14 +8,14 @@ export declare const useDecryptHandles: () => {
     isPending: false;
     isSuccess: false;
     status: "idle";
-    mutate: import("@tanstack/react-query").UseMutateFunction<import("@zama-fhe/relayer-sdk/web").DecryptedResults, Error, HandleContractPair[], 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<import("@zama-fhe/relayer-sdk/web").DecryptedResults, Error, HandleContractPair[], unknown>;
+    mutateAsync: import("@tanstack/react-query").UseMutateAsyncFunction<import("@zama-fhe/relayer-sdk").DecryptedResults, Error, HandleContractPair[], unknown>;
 } | {
     data: undefined;
     variables: HandleContractPair[];
@@ -25,14 +25,14 @@ export declare const useDecryptHandles: () => {
     isPending: true;
     isSuccess: false;
     status: "pending";
-    mutate: import("@tanstack/react-query").UseMutateFunction<import("@zama-fhe/relayer-sdk/web").DecryptedResults, Error, HandleContractPair[], 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<import("@zama-fhe/relayer-sdk/web").DecryptedResults, Error, HandleContractPair[], unknown>;
+    mutateAsync: import("@tanstack/react-query").UseMutateAsyncFunction<import("@zama-fhe/relayer-sdk").DecryptedResults, Error, HandleContractPair[], unknown>;
 } | {
     data: undefined;
     error: Error;
@@ -42,16 +42,16 @@ export declare const useDecryptHandles: () => {
     isPending: false;
     isSuccess: false;
     status: "error";
-    mutate: import("@tanstack/react-query").UseMutateFunction<import("@zama-fhe/relayer-sdk/web").DecryptedResults, Error, HandleContractPair[], 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<import("@zama-fhe/relayer-sdk/web").DecryptedResults, Error, HandleContractPair[], unknown>;
+    mutateAsync: import("@tanstack/react-query").UseMutateAsyncFunction<import("@zama-fhe/relayer-sdk").DecryptedResults, Error, HandleContractPair[], unknown>;
 } | {
-    data: import("@zama-fhe/relayer-sdk/web").DecryptedResults;
+    data: import("@zama-fhe/relayer-sdk").DecryptedResults;
     error: null;
     variables: HandleContractPair[];
     isError: false;
@@ -59,12 +59,12 @@ export declare const useDecryptHandles: () => {
     isPending: false;
     isSuccess: true;
     status: "success";
-    mutate: import("@tanstack/react-query").UseMutateFunction<import("@zama-fhe/relayer-sdk/web").DecryptedResults, Error, HandleContractPair[], 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<import("@zama-fhe/relayer-sdk/web").DecryptedResults, Error, HandleContractPair[], unknown>;
+    mutateAsync: import("@tanstack/react-query").UseMutateAsyncFunction<import("@zama-fhe/relayer-sdk").DecryptedResults, Error, HandleContractPair[], unknown>;
 };

package/dist/hooks/useEncryptValue.js

@@ -10,9 +10,8 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 import { useMutation } from "@tanstack/react-query";
 import { useAccount } from "wagmi";
 import { useFhevmContext } from "../context/FhevmProvider";
-import { encryptInt64 } from "../workers/encryption.worker";
 export const useEncryptValue = ({ tokenAddress }) => {
-    const { instance, config } = useFhevmContext();
+    const { instance } = useFhevmContext();
     const { address } = useAccount();
     const encryptMutation = useMutation({
         mutationFn: (value) => __awaiter(void 0, void 0, void 0, function* () {
@@ -20,10 +19,11 @@ export const useEncryptValue = ({ tokenAddress }) => {
                 throw new Error("Instance is not defined");
             if (!address)
                 throw new Error("User is not connected");
-            return yield encryptInt64(Object.assign({ tokenAddress,
-                address,
-                value,
-                instance }, config));
+            const result = yield instance
+                .createEncryptedInput(tokenAddress, address)
+                .add64(value)
+                .encrypt();
+            return result;
         }),
     });
     return Object.assign({}, encryptMutation);

package/dist/hooks/useEncryptedApprove.js

@@ -1,3 +1,4 @@
+import { padHex } from "viem";
 import { usePerformTransaction } from "./usePerformTransaction";
 import { encryptedABI } from "../types/encryptedABI";
 import { toHexString } from "../utils/string.utils";
@@ -10,7 +11,7 @@ export const useEncryptedApprove = ({ tokenAddress }) => {
     const confidentialApprove = (spender, handles, inputProof) => {
         if (handles.length === 0)
             throw new Error("Bad handles format");
-        const encryptedAmount = toHexString(handles[0]);
+        const encryptedAmount = padHex(toHexString(handles[0]), { size: 32 });
         const proof = toHexString(inputProof);
         perform({
             args: [spender, encryptedAmount, proof],

package/dist/hooks/useFhevmInstance.d.ts

@@ -1,3 +1,3 @@
 export declare const useFhevmInstance: () => {
-    instance: import("@zama-fhe/relayer-sdk/web").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/lib/fhevm.d.ts

@@ -1,5 +1,5 @@
 import { FhevmConfig } from "../types/fhevmConfig";
-import { createInstance, FhevmInstance, SepoliaConfig, initSDK } from "@zama-fhe/relayer-sdk/web";
+import type { createInstance, FhevmInstance, SepoliaConfig, initSDK } from "@zama-fhe/relayer-sdk/bundle";
 declare global {
     interface Window {
         relayerSDK: {

package/dist/lib/fhevm.js

@@ -7,16 +7,15 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
-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* () {
     if (!fhevmInstance) {
-        yield initSDK();
+        yield window.relayerSDK.initSDK();
         if (config) {
-            fhevmInstance = yield createInstance(Object.assign({}, SepoliaConfig));
+            fhevmInstance = yield window.relayerSDK.createInstance(Object.assign({}, window.relayerSDK.SepoliaConfig));
         }
         else {
-            fhevmInstance = yield createInstance(SepoliaConfig);
+            fhevmInstance = yield window.relayerSDK.createInstance(window.relayerSDK.SepoliaConfig);
         }
     }
     return fhevmInstance;