@pyratzlabs/react-fhevm-utils 0.5.0 → 1.0.0

package/dist/context/FhevmProvider.d.ts

@@ -7,6 +7,7 @@ interface ProviderProps {
 }
 interface ContextProps {
     instance?: FhevmInstance;
+    config?: FhevmConfig;
 }
 export declare const FhevmContext: React.Context<ContextProps>;
 declare const FhevmProvider: ({ children, config }: ProviderProps) => import("react/jsx-runtime").JSX.Element;

package/dist/context/FhevmProvider.js

@@ -12,6 +12,7 @@ import { createContext, useContext, useEffect, useState, } from "react";
 import { getOrCreateFhevmInstance } from "../lib/fhevm";
 export const FhevmContext = createContext({
     instance: undefined,
+    config: undefined,
 });
 const FhevmProvider = ({ children, config }) => {
     const [instance, setInstance] = useState();
@@ -27,7 +28,7 @@ const FhevmProvider = ({ children, config }) => {
     useEffect(() => {
         initFhevm();
     }, []);
-    return (_jsx(FhevmContext.Provider, { value: { instance }, children: children }));
+    return (_jsx(FhevmContext.Provider, { value: { instance, config }, children: children }));
 };
 export const useFhevmContext = () => useContext(FhevmContext);
 export default FhevmProvider;

package/dist/hooks/useEncryptValue.d.ts

@@ -0,0 +1,77 @@
+import { Address } from "viem";
+export interface EncryptValueParams {
+    tokenAddress: Address;
+}
+export interface EncryptionResult {
+    handles: Uint8Array[];
+    inputProof: Uint8Array;
+}
+export declare const useEncryptValue: ({ tokenAddress }: EncryptValueParams) => {
+    data: undefined;
+    variables: undefined;
+    error: null;
+    isError: false;
+    isIdle: true;
+    isPending: false;
+    isSuccess: false;
+    status: "idle";
+    mutate: import("@tanstack/react-query").UseMutateFunction<EncryptionResult, 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>;
+} | {
+    data: undefined;
+    variables: bigint;
+    error: null;
+    isError: false;
+    isIdle: false;
+    isPending: true;
+    isSuccess: false;
+    status: "pending";
+    mutate: import("@tanstack/react-query").UseMutateFunction<EncryptionResult, 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>;
+} | {
+    data: undefined;
+    error: Error;
+    variables: bigint;
+    isError: true;
+    isIdle: false;
+    isPending: false;
+    isSuccess: false;
+    status: "error";
+    mutate: import("@tanstack/react-query").UseMutateFunction<EncryptionResult, 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>;
+} | {
+    data: EncryptionResult;
+    error: null;
+    variables: bigint;
+    isError: false;
+    isIdle: false;
+    isPending: false;
+    isSuccess: true;
+    status: "success";
+    mutate: import("@tanstack/react-query").UseMutateFunction<EncryptionResult, 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>;
+};

package/dist/hooks/useEncryptValue.js

@@ -0,0 +1,50 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { useMutation } from "@tanstack/react-query";
+import { useEffect, useRef } from "react";
+import { useAccount } from "wagmi";
+import { useFhevmContext } from "../context/FhevmProvider";
+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 Object.assign({}, encryptMutation);
+};

package/dist/hooks/useEncryptedTransfer.d.ts

@@ -0,0 +1,11 @@
+import { Address } from "viem";
+export interface EncryptedTransferProps {
+    tokenAddress: Address;
+}
+export declare const useEncryptedTransfer: ({ tokenAddress, }: EncryptedTransferProps) => {
+    transfer: (to: Address, handles: Uint8Array[], inputProof: Uint8Array) => void;
+    isLoading: boolean;
+    isFailed: boolean;
+    isSuccess: boolean;
+    error: import("@wagmi/core").WriteContractErrorType | null;
+};

package/dist/hooks/useEncryptedTransfer.js

@@ -0,0 +1,20 @@
+import { usePerformTransaction } from "./usePerformTransaction";
+import { encryptedABI } from "../types/encryptedABI";
+import { toHexString } from "../utils/string.utils";
+export const useEncryptedTransfer = ({ tokenAddress, }) => {
+    const { perform, isLoading, isFailed, isSuccess, error } = usePerformTransaction({
+        abi: encryptedABI,
+        address: tokenAddress,
+        functionName: "transfer",
+    });
+    const transfer = (to, handles, inputProof) => {
+        if (handles.length === 0)
+            throw new Error("Bad handles format");
+        const encryptedAmount = toHexString(handles[0]);
+        const proof = toHexString(inputProof);
+        perform({
+            args: [to, encryptedAmount, proof],
+        });
+    };
+    return { transfer, isLoading, isFailed, isSuccess, error };
+};

package/dist/hooks/useGetFhevmConfig.d.ts

@@ -0,0 +1,3 @@
+export declare const useGetFhevmConfig: () => {
+    config: import("..").FhevmConfig | undefined;
+};

package/dist/hooks/useGetFhevmConfig.js

@@ -0,0 +1,5 @@
+import { useFhevmContext } from "../context/FhevmProvider";
+export const useGetFhevmConfig = () => {
+    const { config } = useFhevmContext();
+    return { config };
+};

package/dist/index.d.ts

@@ -2,3 +2,6 @@ export { default } from "./context/FhevmProvider";
 export { useFhevmInstance } from "./hooks/useFhevmInstance";
 export { useDecryptBalance } from "./hooks/useDecryptBalance";
 export { useGetEncryptedBalance } from "./hooks/useGetEncryptedBalance";
+export { useEncryptedTransfer } from "./hooks/useEncryptedTransfer";
+export { useEncryptValue } from "./hooks/useEncryptValue";
+export { type FhevmConfig } from "./types/fhevmConfig";

package/dist/index.js

@@ -4,3 +4,5 @@ export { default } from "./context/FhevmProvider";
 export { useFhevmInstance } from "./hooks/useFhevmInstance";
 export { useDecryptBalance } from "./hooks/useDecryptBalance";
 export { useGetEncryptedBalance } from "./hooks/useGetEncryptedBalance";
+export { useEncryptedTransfer } from "./hooks/useEncryptedTransfer";
+export { useEncryptValue } from "./hooks/useEncryptValue";

package/dist/utils/string.utils.d.ts

@@ -0,0 +1,2 @@
+import { Address } from "viem";
+export declare const toHexString: (bytes: Uint8Array) => Address;

package/dist/utils/string.utils.js

@@ -0,0 +1,5 @@
+export const toHexString = (bytes) => {
+    const hexString = "0x" +
+        bytes.reduce((str, byte) => str + byte.toString(16).padStart(2, "0"), "");
+    return hexString;
+};

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

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

package/dist/workers/encryption.worker.js

@@ -0,0 +1,35 @@
+/// <reference lib="webworker" />
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        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,
+    });
+    if (!instance || !address) {
+        ctx.postMessage({ error: "Instance or address is undefined" });
+        return;
+    }
+    try {
+        const result = yield instance
+            .createEncryptedInput(tokenAddress, address)
+            .add64(value)
+            .encrypt();
+        ctx.postMessage({ result });
+    }
+    catch (error) {
+        console.error("Worker error", error);
+        ctx.postMessage({ error });
+    }
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pyratzlabs/react-fhevm-utils",
-  "version": "0.5.0",
+  "version": "1.0.0",
   "description": "React hooks and utilities for Fhevmjs",
   "main": "dist/index.js",
   "files": [