@pyratzlabs/react-fhevm-utils 0.4.0

package/dist/config.d.ts

@@ -0,0 +1,6 @@
+export declare const config: {
+    ACL_ADDRESS: string;
+    KMS_ADDRESS: string;
+    GATEWAY_URL: string;
+    RPC_URL: string;
+};

package/dist/config.js

@@ -0,0 +1,6 @@
+export const config = {
+    ACL_ADDRESS: "0xFee8407e2f5e3Ee68ad77cAE98c434e637f516e5",
+    KMS_ADDRESS: "0x9D6891A6240D6130c54ae243d8005063D05fE14b",
+    GATEWAY_URL: "https://gateway.sepolia.zama.ai/",
+    RPC_URL: "https://eth-sepolia.g.alchemy.com/v2/z7ESc-2NGy8mOHByrhAENi2XbZHbW6dl",
+};

package/dist/context/FhevmProvider.d.ts

@@ -0,0 +1,14 @@
+import React, { ReactNode } from "react";
+import { FhevmInstance } from "fhevmjs";
+import { FhevmConfig } from "../types/fhevmConfig";
+interface ProviderProps {
+    children: ReactNode;
+    config?: FhevmConfig;
+}
+interface ContextProps {
+    instance?: FhevmInstance;
+}
+export declare const FhevmContext: React.Context<ContextProps>;
+declare const FhevmProvider: ({ children, config }: ProviderProps) => import("react/jsx-runtime").JSX.Element;
+export declare const useFhevmContext: () => ContextProps;
+export default FhevmProvider;

package/dist/context/FhevmProvider.js

@@ -0,0 +1,33 @@
+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 { jsx as _jsx } from "react/jsx-runtime";
+import { createContext, useContext, useEffect, useState, } from "react";
+import { getOrCreateFhevmInstance } from "../lib/fhevm";
+export const FhevmContext = createContext({
+    instance: undefined,
+});
+const FhevmProvider = ({ children, config }) => {
+    const [instance, setInstance] = useState();
+    const initFhevm = () => __awaiter(void 0, void 0, void 0, function* () {
+        try {
+            const instance = yield getOrCreateFhevmInstance(config);
+            setInstance(instance);
+        }
+        catch (error) {
+            throw new Error(`Failed to initialize FHEVM: ${error}`);
+        }
+    });
+    useEffect(() => {
+        initFhevm();
+    }, []);
+    return (_jsx(FhevmContext.Provider, { value: { instance }, children: children }));
+};
+export const useFhevmContext = () => useContext(FhevmContext);
+export default FhevmProvider;

package/dist/hooks/useDecryptBalance.d.ts

@@ -0,0 +1,73 @@
+import { Address } from "viem";
+export interface DecryptBalanceParams {
+    tokenAddress: Address;
+}
+export declare const useDecryptBalance: ({ tokenAddress }: DecryptBalanceParams) => {
+    data: undefined;
+    variables: undefined;
+    error: null;
+    isError: false;
+    isIdle: true;
+    isPending: false;
+    isSuccess: false;
+    status: "idle";
+    mutate: import("@tanstack/react-query").UseMutateFunction<number, Error, bigint, unknown>;
+    reset: () => void;
+    context: unknown;
+    failureCount: number;
+    failureReason: Error | null;
+    isPaused: boolean;
+    submittedAt: number;
+    mutateAsync: import("@tanstack/react-query").UseMutateAsyncFunction<number, 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<number, Error, bigint, unknown>;
+    reset: () => void;
+    context: unknown;
+    failureCount: number;
+    failureReason: Error | null;
+    isPaused: boolean;
+    submittedAt: number;
+    mutateAsync: import("@tanstack/react-query").UseMutateAsyncFunction<number, 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<number, Error, bigint, unknown>;
+    reset: () => void;
+    context: unknown;
+    failureCount: number;
+    failureReason: Error | null;
+    isPaused: boolean;
+    submittedAt: number;
+    mutateAsync: import("@tanstack/react-query").UseMutateAsyncFunction<number, Error, bigint, unknown>;
+} | {
+    data: number;
+    error: null;
+    variables: bigint;
+    isError: false;
+    isIdle: false;
+    isPending: false;
+    isSuccess: true;
+    status: "success";
+    mutate: import("@tanstack/react-query").UseMutateFunction<number, Error, bigint, unknown>;
+    reset: () => void;
+    context: unknown;
+    failureCount: number;
+    failureReason: Error | null;
+    isPaused: boolean;
+    submittedAt: number;
+    mutateAsync: import("@tanstack/react-query").UseMutateAsyncFunction<number, Error, bigint, unknown>;
+};

package/dist/hooks/useDecryptBalance.js

@@ -0,0 +1,36 @@
+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 { useAccount, useSignTypedData } from "wagmi";
+import { useFhevmContext } from "../context/FhevmProvider";
+export const useDecryptBalance = ({ tokenAddress }) => {
+    const { instance } = useFhevmContext();
+    const { address } = useAccount();
+    const { signTypedDataAsync } = useSignTypedData();
+    const decryptMutation = useMutation({
+        mutationFn: (encryptedBalance) => __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 { publicKey, privateKey } = instance.generateKeypair();
+            const eip712 = instance.createEIP712(publicKey, tokenAddress);
+            const signature = yield signTypedDataAsync({
+                domain: eip712.domain,
+                types: { Reencrypt: eip712.types.Reencrypt },
+                primaryType: "Reencrypt",
+                message: eip712.message,
+            });
+            const decryptedBalance = yield instance.reencrypt(encryptedBalance, privateKey, publicKey, signature.replace("0x", ""), tokenAddress, address);
+            return Number(decryptedBalance);
+        }),
+    });
+    return Object.assign({}, decryptMutation);
+};

package/dist/hooks/useFhevmInstance.d.ts

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

package/dist/hooks/useFhevmInstance.js

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

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+export { default } from "./context/FhevmProvider";
+export { useFhevmInstance } from "./hooks/useFhevmInstance";
+export { useDecryptBalance } from "./hooks/useDecryptBalance";

package/dist/index.js

@@ -0,0 +1,5 @@
+// context
+export { default } from "./context/FhevmProvider";
+// hooks
+export { useFhevmInstance } from "./hooks/useFhevmInstance";
+export { useDecryptBalance } from "./hooks/useDecryptBalance";

package/dist/lib/fhevm.d.ts

@@ -0,0 +1,5 @@
+import { FhevmInstance } from "fhevmjs";
+import { FhevmConfig } from "../types/fhevmConfig";
+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

@@ -0,0 +1,38 @@
+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 { 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,
+        });
+    }
+    return fhevmInstance;
+});
+export const getOrCreateFhevmInstance = (config) => __awaiter(void 0, void 0, void 0, function* () {
+    if (!fhevmInstance) {
+        fhevmInstance = yield createFhevmInstance(config);
+    }
+    return fhevmInstance;
+});
+export const getInstance = () => {
+    return fhevmInstance;
+};

package/dist/types/fhevmConfig.d.ts

@@ -0,0 +1,6 @@
+import { EIP1193Provider } from "viem";
+export interface FhevmConfig {
+    chainId?: number;
+    network?: EIP1193Provider;
+    networkUrl?: string;
+}

package/dist/types/fhevmConfig.js

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

package/package.json

@@ -0,0 +1,39 @@
+{
+  "name": "@pyratzlabs/react-fhevm-utils",
+  "version": "0.4.0",
+  "description": "React hooks and utilities for Fhevmjs",
+  "main": "dist/index.js",
+  "files": [
+    "dist"
+  ],
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    }
+  },
+  "scripts": {
+    "build": "tsc",
+    "test": "npm run test",
+    "clean": "rm -rf dist",
+    "preversion": "npm run build",
+    "version": "npm publish --access=public"
+  },
+  "keywords": [
+    "fhevm"
+  ],
+  "author": "Pyratzlabs",
+  "license": "MIT",
+  "devDependencies": {
+    "@types/react": "^19.1.0",
+    "ts-node": "^10.9.2",
+    "typescript": "^5.8.2"
+  },
+  "dependencies": {
+    "@tanstack/react-query": "^5.71.5",
+    "fhevmjs": "^0.6.2",
+    "react": "^19.1.0",
+    "viem": "^2.25.0",
+    "wagmi": "^2.14.16"
+  }
+}