@pyratzlabs/react-fhevm-utils 0.4.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/useGetEncryptedBalance.d.ts

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

package/dist/hooks/useGetEncryptedBalance.js

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

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/hooks/usePerformTransaction.d.ts

@@ -0,0 +1,17 @@
+import { Abi, Address, ContractFunctionArgs, ContractFunctionName } from "viem";
+interface Props<TAbi extends Abi, TFunction extends ContractFunctionName<TAbi, "nonpayable" | "payable">> {
+    abi: TAbi;
+    address: Address;
+    functionName: TFunction;
+}
+export declare const usePerformTransaction: <TAbi extends Abi, TFunction extends ContractFunctionName<TAbi, "nonpayable" | "payable">>({ abi, address, functionName, }: Props<TAbi, TFunction>) => {
+    error: import("@wagmi/core").WriteContractErrorType | null;
+    isSuccess: boolean;
+    isLoading: boolean;
+    isFailed: boolean;
+    perform: ({ args, value, }: {
+        args: ContractFunctionArgs<TAbi, "nonpayable" | "payable", TFunction>;
+        value?: bigint;
+    }) => Promise<void>;
+};
+export {};

package/dist/hooks/usePerformTransaction.js

@@ -0,0 +1,40 @@
+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 { useConfig, useWaitForTransactionReceipt, useWriteContract, } from "wagmi";
+import { simulateContract } from "@wagmi/core";
+export const usePerformTransaction = ({ abi, address, functionName, }) => {
+    const config = useConfig();
+    const { writeContract, data: writeContractData, isError: isWriteError, error, } = useWriteContract();
+    const { isSuccess, isLoading, isError } = useWaitForTransactionReceipt({
+        hash: writeContractData,
+    });
+    const perform = (_a) => __awaiter(void 0, [_a], void 0, function* ({ args, value, }) {
+        try {
+            const result = yield simulateContract(config, {
+                address,
+                abi: abi,
+                functionName,
+                value,
+                args: args,
+            });
+            writeContract(result.request);
+        }
+        catch (error) {
+            throw new Error(`Simulation failed: ${error}`);
+        }
+    });
+    return {
+        error,
+        isSuccess,
+        isLoading,
+        isFailed: isError || isWriteError,
+        perform,
+    };
+};

package/dist/index.d.ts

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

@@ -3,3 +3,6 @@ export { default } from "./context/FhevmProvider";
 // hooks
 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/types/encryptedABI.d.ts

@@ -0,0 +1,472 @@
+export declare const encryptedABI: readonly [{
+    readonly inputs: readonly [{
+        readonly internalType: "string";
+        readonly name: "name_";
+        readonly type: "string";
+    }, {
+        readonly internalType: "string";
+        readonly name: "symbol_";
+        readonly type: "string";
+    }, {
+        readonly internalType: "address";
+        readonly name: "admin_";
+        readonly type: "address";
+    }];
+    readonly stateMutability: "nonpayable";
+    readonly type: "constructor";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "address";
+        readonly name: "spender";
+        readonly type: "address";
+    }, {
+        readonly internalType: "uint256";
+        readonly name: "allowance";
+        readonly type: "uint256";
+    }, {
+        readonly internalType: "uint256";
+        readonly name: "needed";
+        readonly type: "uint256";
+    }];
+    readonly name: "ERC20InsufficientAllowance";
+    readonly type: "error";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "address";
+        readonly name: "sender";
+        readonly type: "address";
+    }, {
+        readonly internalType: "uint256";
+        readonly name: "balance";
+        readonly type: "uint256";
+    }, {
+        readonly internalType: "uint256";
+        readonly name: "needed";
+        readonly type: "uint256";
+    }];
+    readonly name: "ERC20InsufficientBalance";
+    readonly type: "error";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "address";
+        readonly name: "approver";
+        readonly type: "address";
+    }];
+    readonly name: "ERC20InvalidApprover";
+    readonly type: "error";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "address";
+        readonly name: "receiver";
+        readonly type: "address";
+    }];
+    readonly name: "ERC20InvalidReceiver";
+    readonly type: "error";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "address";
+        readonly name: "sender";
+        readonly type: "address";
+    }];
+    readonly name: "ERC20InvalidSender";
+    readonly type: "error";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "address";
+        readonly name: "spender";
+        readonly type: "address";
+    }];
+    readonly name: "ERC20InvalidSpender";
+    readonly type: "error";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "address";
+        readonly name: "owner";
+        readonly type: "address";
+    }];
+    readonly name: "OwnableInvalidOwner";
+    readonly type: "error";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "address";
+        readonly name: "account";
+        readonly type: "address";
+    }];
+    readonly name: "OwnableUnauthorizedAccount";
+    readonly type: "error";
+}, {
+    readonly inputs: readonly [];
+    readonly name: "TFHESenderNotAllowed";
+    readonly type: "error";
+}, {
+    readonly anonymous: false;
+    readonly inputs: readonly [{
+        readonly indexed: true;
+        readonly internalType: "address";
+        readonly name: "owner";
+        readonly type: "address";
+    }, {
+        readonly indexed: true;
+        readonly internalType: "address";
+        readonly name: "spender";
+        readonly type: "address";
+    }, {
+        readonly indexed: false;
+        readonly internalType: "uint256";
+        readonly name: "placeholder";
+        readonly type: "uint256";
+    }];
+    readonly name: "Approval";
+    readonly type: "event";
+}, {
+    readonly anonymous: false;
+    readonly inputs: readonly [{
+        readonly indexed: true;
+        readonly internalType: "address";
+        readonly name: "to";
+        readonly type: "address";
+    }, {
+        readonly indexed: false;
+        readonly internalType: "uint64";
+        readonly name: "amount";
+        readonly type: "uint64";
+    }];
+    readonly name: "Mint";
+    readonly type: "event";
+}, {
+    readonly anonymous: false;
+    readonly inputs: readonly [{
+        readonly indexed: true;
+        readonly internalType: "address";
+        readonly name: "previousOwner";
+        readonly type: "address";
+    }, {
+        readonly indexed: true;
+        readonly internalType: "address";
+        readonly name: "newOwner";
+        readonly type: "address";
+    }];
+    readonly name: "OwnershipTransferStarted";
+    readonly type: "event";
+}, {
+    readonly anonymous: false;
+    readonly inputs: readonly [{
+        readonly indexed: true;
+        readonly internalType: "address";
+        readonly name: "previousOwner";
+        readonly type: "address";
+    }, {
+        readonly indexed: true;
+        readonly internalType: "address";
+        readonly name: "newOwner";
+        readonly type: "address";
+    }];
+    readonly name: "OwnershipTransferred";
+    readonly type: "event";
+}, {
+    readonly anonymous: false;
+    readonly inputs: readonly [{
+        readonly indexed: true;
+        readonly internalType: "address";
+        readonly name: "from";
+        readonly type: "address";
+    }, {
+        readonly indexed: true;
+        readonly internalType: "address";
+        readonly name: "to";
+        readonly type: "address";
+    }, {
+        readonly indexed: false;
+        readonly internalType: "uint256";
+        readonly name: "transferId";
+        readonly type: "uint256";
+    }];
+    readonly name: "Transfer";
+    readonly type: "event";
+}, {
+    readonly anonymous: false;
+    readonly inputs: readonly [{
+        readonly indexed: true;
+        readonly internalType: "address";
+        readonly name: "from";
+        readonly type: "address";
+    }, {
+        readonly indexed: true;
+        readonly internalType: "address";
+        readonly name: "to";
+        readonly type: "address";
+    }, {
+        readonly indexed: false;
+        readonly internalType: "euint64";
+        readonly name: "amount";
+        readonly type: "uint256";
+    }];
+    readonly name: "TransferInfo";
+    readonly type: "event";
+}, {
+    readonly inputs: readonly [];
+    readonly name: "acceptOwnership";
+    readonly outputs: readonly [];
+    readonly stateMutability: "nonpayable";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "address";
+        readonly name: "owner";
+        readonly type: "address";
+    }, {
+        readonly internalType: "address";
+        readonly name: "spender";
+        readonly type: "address";
+    }];
+    readonly name: "allowance";
+    readonly outputs: readonly [{
+        readonly internalType: "euint64";
+        readonly name: "";
+        readonly type: "uint256";
+    }];
+    readonly stateMutability: "view";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "address";
+        readonly name: "spender";
+        readonly type: "address";
+    }, {
+        readonly internalType: "euint64";
+        readonly name: "amount";
+        readonly type: "uint256";
+    }];
+    readonly name: "approve";
+    readonly outputs: readonly [{
+        readonly internalType: "bool";
+        readonly name: "";
+        readonly type: "bool";
+    }];
+    readonly stateMutability: "nonpayable";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "address";
+        readonly name: "spender";
+        readonly type: "address";
+    }, {
+        readonly internalType: "einput";
+        readonly name: "encryptedAmount";
+        readonly type: "bytes32";
+    }, {
+        readonly internalType: "bytes";
+        readonly name: "inputProof";
+        readonly type: "bytes";
+    }];
+    readonly name: "approve";
+    readonly outputs: readonly [{
+        readonly internalType: "bool";
+        readonly name: "";
+        readonly type: "bool";
+    }];
+    readonly stateMutability: "nonpayable";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "address";
+        readonly name: "account";
+        readonly type: "address";
+    }];
+    readonly name: "balanceOf";
+    readonly outputs: readonly [{
+        readonly internalType: "euint64";
+        readonly name: "";
+        readonly type: "uint256";
+    }];
+    readonly stateMutability: "view";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [];
+    readonly name: "decimals";
+    readonly outputs: readonly [{
+        readonly internalType: "uint8";
+        readonly name: "";
+        readonly type: "uint8";
+    }];
+    readonly stateMutability: "view";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "address";
+        readonly name: "to";
+        readonly type: "address";
+    }, {
+        readonly internalType: "uint64";
+        readonly name: "amount";
+        readonly type: "uint64";
+    }];
+    readonly name: "mint";
+    readonly outputs: readonly [];
+    readonly stateMutability: "nonpayable";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "address";
+        readonly name: "to";
+        readonly type: "address";
+    }];
+    readonly name: "mintTenThousand";
+    readonly outputs: readonly [];
+    readonly stateMutability: "nonpayable";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [];
+    readonly name: "name";
+    readonly outputs: readonly [{
+        readonly internalType: "string";
+        readonly name: "";
+        readonly type: "string";
+    }];
+    readonly stateMutability: "view";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [];
+    readonly name: "owner";
+    readonly outputs: readonly [{
+        readonly internalType: "address";
+        readonly name: "";
+        readonly type: "address";
+    }];
+    readonly stateMutability: "view";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [];
+    readonly name: "pendingOwner";
+    readonly outputs: readonly [{
+        readonly internalType: "address";
+        readonly name: "";
+        readonly type: "address";
+    }];
+    readonly stateMutability: "view";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [];
+    readonly name: "renounceOwnership";
+    readonly outputs: readonly [];
+    readonly stateMutability: "nonpayable";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [];
+    readonly name: "symbol";
+    readonly outputs: readonly [{
+        readonly internalType: "string";
+        readonly name: "";
+        readonly type: "string";
+    }];
+    readonly stateMutability: "view";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [];
+    readonly name: "totalSupply";
+    readonly outputs: readonly [{
+        readonly internalType: "uint64";
+        readonly name: "";
+        readonly type: "uint64";
+    }];
+    readonly stateMutability: "view";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "address";
+        readonly name: "to";
+        readonly type: "address";
+    }, {
+        readonly internalType: "einput";
+        readonly name: "encryptedAmount";
+        readonly type: "bytes32";
+    }, {
+        readonly internalType: "bytes";
+        readonly name: "inputProof";
+        readonly type: "bytes";
+    }];
+    readonly name: "transfer";
+    readonly outputs: readonly [{
+        readonly internalType: "bool";
+        readonly name: "";
+        readonly type: "bool";
+    }];
+    readonly stateMutability: "nonpayable";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "address";
+        readonly name: "to";
+        readonly type: "address";
+    }, {
+        readonly internalType: "euint64";
+        readonly name: "amount";
+        readonly type: "uint256";
+    }];
+    readonly name: "transfer";
+    readonly outputs: readonly [{
+        readonly internalType: "bool";
+        readonly name: "";
+        readonly type: "bool";
+    }];
+    readonly stateMutability: "nonpayable";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "address";
+        readonly name: "from";
+        readonly type: "address";
+    }, {
+        readonly internalType: "address";
+        readonly name: "to";
+        readonly type: "address";
+    }, {
+        readonly internalType: "euint64";
+        readonly name: "amount";
+        readonly type: "uint256";
+    }];
+    readonly name: "transferFrom";
+    readonly outputs: readonly [{
+        readonly internalType: "bool";
+        readonly name: "";
+        readonly type: "bool";
+    }];
+    readonly stateMutability: "nonpayable";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "address";
+        readonly name: "from";
+        readonly type: "address";
+    }, {
+        readonly internalType: "address";
+        readonly name: "to";
+        readonly type: "address";
+    }, {
+        readonly internalType: "einput";
+        readonly name: "encryptedAmount";
+        readonly type: "bytes32";
+    }, {
+        readonly internalType: "bytes";
+        readonly name: "inputProof";
+        readonly type: "bytes";
+    }];
+    readonly name: "transferFrom";
+    readonly outputs: readonly [{
+        readonly internalType: "bool";
+        readonly name: "";
+        readonly type: "bool";
+    }];
+    readonly stateMutability: "nonpayable";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "address";
+        readonly name: "newOwner";
+        readonly type: "address";
+    }];
+    readonly name: "transferOwnership";
+    readonly outputs: readonly [];
+    readonly stateMutability: "nonpayable";
+    readonly type: "function";
+}];

package/dist/types/encryptedABI.js

@@ -0,0 +1,329 @@
+export const encryptedABI = [
+    {
+        inputs: [
+            { internalType: "string", name: "name_", type: "string" },
+            { internalType: "string", name: "symbol_", type: "string" },
+            { internalType: "address", name: "admin_", type: "address" },
+        ],
+        stateMutability: "nonpayable",
+        type: "constructor",
+    },
+    {
+        inputs: [
+            { internalType: "address", name: "spender", type: "address" },
+            { internalType: "uint256", name: "allowance", type: "uint256" },
+            { internalType: "uint256", name: "needed", type: "uint256" },
+        ],
+        name: "ERC20InsufficientAllowance",
+        type: "error",
+    },
+    {
+        inputs: [
+            { internalType: "address", name: "sender", type: "address" },
+            { internalType: "uint256", name: "balance", type: "uint256" },
+            { internalType: "uint256", name: "needed", type: "uint256" },
+        ],
+        name: "ERC20InsufficientBalance",
+        type: "error",
+    },
+    {
+        inputs: [{ internalType: "address", name: "approver", type: "address" }],
+        name: "ERC20InvalidApprover",
+        type: "error",
+    },
+    {
+        inputs: [{ internalType: "address", name: "receiver", type: "address" }],
+        name: "ERC20InvalidReceiver",
+        type: "error",
+    },
+    {
+        inputs: [{ internalType: "address", name: "sender", type: "address" }],
+        name: "ERC20InvalidSender",
+        type: "error",
+    },
+    {
+        inputs: [{ internalType: "address", name: "spender", type: "address" }],
+        name: "ERC20InvalidSpender",
+        type: "error",
+    },
+    {
+        inputs: [{ internalType: "address", name: "owner", type: "address" }],
+        name: "OwnableInvalidOwner",
+        type: "error",
+    },
+    {
+        inputs: [{ internalType: "address", name: "account", type: "address" }],
+        name: "OwnableUnauthorizedAccount",
+        type: "error",
+    },
+    { inputs: [], name: "TFHESenderNotAllowed", type: "error" },
+    {
+        anonymous: false,
+        inputs: [
+            {
+                indexed: true,
+                internalType: "address",
+                name: "owner",
+                type: "address",
+            },
+            {
+                indexed: true,
+                internalType: "address",
+                name: "spender",
+                type: "address",
+            },
+            {
+                indexed: false,
+                internalType: "uint256",
+                name: "placeholder",
+                type: "uint256",
+            },
+        ],
+        name: "Approval",
+        type: "event",
+    },
+    {
+        anonymous: false,
+        inputs: [
+            { indexed: true, internalType: "address", name: "to", type: "address" },
+            {
+                indexed: false,
+                internalType: "uint64",
+                name: "amount",
+                type: "uint64",
+            },
+        ],
+        name: "Mint",
+        type: "event",
+    },
+    {
+        anonymous: false,
+        inputs: [
+            {
+                indexed: true,
+                internalType: "address",
+                name: "previousOwner",
+                type: "address",
+            },
+            {
+                indexed: true,
+                internalType: "address",
+                name: "newOwner",
+                type: "address",
+            },
+        ],
+        name: "OwnershipTransferStarted",
+        type: "event",
+    },
+    {
+        anonymous: false,
+        inputs: [
+            {
+                indexed: true,
+                internalType: "address",
+                name: "previousOwner",
+                type: "address",
+            },
+            {
+                indexed: true,
+                internalType: "address",
+                name: "newOwner",
+                type: "address",
+            },
+        ],
+        name: "OwnershipTransferred",
+        type: "event",
+    },
+    {
+        anonymous: false,
+        inputs: [
+            { indexed: true, internalType: "address", name: "from", type: "address" },
+            { indexed: true, internalType: "address", name: "to", type: "address" },
+            {
+                indexed: false,
+                internalType: "uint256",
+                name: "transferId",
+                type: "uint256",
+            },
+        ],
+        name: "Transfer",
+        type: "event",
+    },
+    {
+        anonymous: false,
+        inputs: [
+            { indexed: true, internalType: "address", name: "from", type: "address" },
+            { indexed: true, internalType: "address", name: "to", type: "address" },
+            {
+                indexed: false,
+                internalType: "euint64",
+                name: "amount",
+                type: "uint256",
+            },
+        ],
+        name: "TransferInfo",
+        type: "event",
+    },
+    {
+        inputs: [],
+        name: "acceptOwnership",
+        outputs: [],
+        stateMutability: "nonpayable",
+        type: "function",
+    },
+    {
+        inputs: [
+            { internalType: "address", name: "owner", type: "address" },
+            { internalType: "address", name: "spender", type: "address" },
+        ],
+        name: "allowance",
+        outputs: [{ internalType: "euint64", name: "", type: "uint256" }],
+        stateMutability: "view",
+        type: "function",
+    },
+    {
+        inputs: [
+            { internalType: "address", name: "spender", type: "address" },
+            { internalType: "euint64", name: "amount", type: "uint256" },
+        ],
+        name: "approve",
+        outputs: [{ internalType: "bool", name: "", type: "bool" }],
+        stateMutability: "nonpayable",
+        type: "function",
+    },
+    {
+        inputs: [
+            { internalType: "address", name: "spender", type: "address" },
+            { internalType: "einput", name: "encryptedAmount", type: "bytes32" },
+            { internalType: "bytes", name: "inputProof", type: "bytes" },
+        ],
+        name: "approve",
+        outputs: [{ internalType: "bool", name: "", type: "bool" }],
+        stateMutability: "nonpayable",
+        type: "function",
+    },
+    {
+        inputs: [{ internalType: "address", name: "account", type: "address" }],
+        name: "balanceOf",
+        outputs: [{ internalType: "euint64", name: "", type: "uint256" }],
+        stateMutability: "view",
+        type: "function",
+    },
+    {
+        inputs: [],
+        name: "decimals",
+        outputs: [{ internalType: "uint8", name: "", type: "uint8" }],
+        stateMutability: "view",
+        type: "function",
+    },
+    {
+        inputs: [
+            { internalType: "address", name: "to", type: "address" },
+            { internalType: "uint64", name: "amount", type: "uint64" },
+        ],
+        name: "mint",
+        outputs: [],
+        stateMutability: "nonpayable",
+        type: "function",
+    },
+    {
+        inputs: [{ internalType: "address", name: "to", type: "address" }],
+        name: "mintTenThousand",
+        outputs: [],
+        stateMutability: "nonpayable",
+        type: "function",
+    },
+    {
+        inputs: [],
+        name: "name",
+        outputs: [{ internalType: "string", name: "", type: "string" }],
+        stateMutability: "view",
+        type: "function",
+    },
+    {
+        inputs: [],
+        name: "owner",
+        outputs: [{ internalType: "address", name: "", type: "address" }],
+        stateMutability: "view",
+        type: "function",
+    },
+    {
+        inputs: [],
+        name: "pendingOwner",
+        outputs: [{ internalType: "address", name: "", type: "address" }],
+        stateMutability: "view",
+        type: "function",
+    },
+    {
+        inputs: [],
+        name: "renounceOwnership",
+        outputs: [],
+        stateMutability: "nonpayable",
+        type: "function",
+    },
+    {
+        inputs: [],
+        name: "symbol",
+        outputs: [{ internalType: "string", name: "", type: "string" }],
+        stateMutability: "view",
+        type: "function",
+    },
+    {
+        inputs: [],
+        name: "totalSupply",
+        outputs: [{ internalType: "uint64", name: "", type: "uint64" }],
+        stateMutability: "view",
+        type: "function",
+    },
+    {
+        inputs: [
+            { internalType: "address", name: "to", type: "address" },
+            { internalType: "einput", name: "encryptedAmount", type: "bytes32" },
+            { internalType: "bytes", name: "inputProof", type: "bytes" },
+        ],
+        name: "transfer",
+        outputs: [{ internalType: "bool", name: "", type: "bool" }],
+        stateMutability: "nonpayable",
+        type: "function",
+    },
+    {
+        inputs: [
+            { internalType: "address", name: "to", type: "address" },
+            { internalType: "euint64", name: "amount", type: "uint256" },
+        ],
+        name: "transfer",
+        outputs: [{ internalType: "bool", name: "", type: "bool" }],
+        stateMutability: "nonpayable",
+        type: "function",
+    },
+    {
+        inputs: [
+            { internalType: "address", name: "from", type: "address" },
+            { internalType: "address", name: "to", type: "address" },
+            { internalType: "euint64", name: "amount", type: "uint256" },
+        ],
+        name: "transferFrom",
+        outputs: [{ internalType: "bool", name: "", type: "bool" }],
+        stateMutability: "nonpayable",
+        type: "function",
+    },
+    {
+        inputs: [
+            { internalType: "address", name: "from", type: "address" },
+            { internalType: "address", name: "to", type: "address" },
+            { internalType: "einput", name: "encryptedAmount", type: "bytes32" },
+            { internalType: "bytes", name: "inputProof", type: "bytes" },
+        ],
+        name: "transferFrom",
+        outputs: [{ internalType: "bool", name: "", type: "bool" }],
+        stateMutability: "nonpayable",
+        type: "function",
+    },
+    {
+        inputs: [{ internalType: "address", name: "newOwner", type: "address" }],
+        name: "transferOwnership",
+        outputs: [],
+        stateMutability: "nonpayable",
+        type: "function",
+    },
+];

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.4.0",
+  "version": "1.0.0",
   "description": "React hooks and utilities for Fhevmjs",
   "main": "dist/index.js",
   "files": [