@trezo/evm 0.1.0

package/dist/index.mjs

@@ -0,0 +1,439 @@
+// src/types/config.ts
+import * as Chains from "viem/chains";
+var EvmChains = Chains;
+
+// src/factory/create.tsx
+import React, { useSyncExternalStore } from "react";
+
+// src/store/evm.store.ts
+import { ethers } from "ethers";
+
+// src/store/state.ts
+var getInitialState = () => ({
+  wallet: {
+    isConnected: false,
+    isConnecting: false,
+    address: void 0,
+    chainId: void 0,
+    error: void 0
+  },
+  provider: {
+    isAvailable: typeof window !== "undefined" && !!window.ethereum,
+    error: void 0
+  },
+  _signer: void 0,
+  _provider: void 0,
+  _contract: void 0,
+  _abi: void 0
+});
+
+// src/utils/events.ts
+var createEventPoller = ({ provider, contract, eventName, intervalMs = 5e3 }, listener) => {
+  let lastBlock;
+  const poll = async () => {
+    try {
+      const currentBlock = await provider.getBlockNumber();
+      if (!lastBlock) {
+        lastBlock = currentBlock;
+        return;
+      }
+      if (currentBlock > lastBlock) {
+        const logs = await provider.getLogs({
+          address: await contract.getAddress(),
+          fromBlock: lastBlock + 1,
+          toBlock: currentBlock,
+          topics: [contract.interface.getEvent(eventName).topicHash]
+        });
+        logs.forEach((log) => {
+          const parsed = contract.interface.parseLog(log);
+          if (parsed) listener(...parsed.args);
+        });
+        lastBlock = currentBlock;
+      }
+    } catch (err) {
+      console.error("Event Polling Error:", err);
+    }
+  };
+  const intervalId = setInterval(poll, intervalMs);
+  return () => clearInterval(intervalId);
+};
+
+// src/utils/errors.ts
+function throwError(message) {
+  throw new Error(message ?? "An unexpected error occurred");
+}
+var mapEthersError = (error) => {
+  if (!error) return "Unknown blockchain error.";
+  const message = error.message?.toLowerCase?.() || "";
+  if (error.code === "ACTION_REJECTED" || error.code === 4001) {
+    return "Transaction was rejected in the wallet.";
+  }
+  if (error.code === "CANCELLED") {
+    return "The blockchain request was cancelled.";
+  }
+  if (error.code === "CALL_EXCEPTION") {
+    return `Smart contract execution reverted${error.reason ? `: ${error.reason}` : "."}`;
+  }
+  if (error.code === "INSUFFICIENT_FUNDS" || message.includes("insufficient funds")) {
+    return "Your wallet does not have enough ETH to pay for gas or value.";
+  }
+  if (error.code === "NONCE_EXPIRED") {
+    return "Transaction nonce is too low. Try resetting your wallet nonce.";
+  }
+  if (error.code === "REPLACEMENT_UNDERPRICED") {
+    return "Replacement transaction gas price is too low.";
+  }
+  if (error.code === "TRANSACTION_REPLACED") {
+    return "The transaction was replaced by another transaction.";
+  }
+  if (error.code === "NETWORK_ERROR") {
+    return "Network connection failed. Check your internet or RPC endpoint.";
+  }
+  if (error.code === "SERVER_ERROR") {
+    return "Blockchain RPC server returned an error.";
+  }
+  if (error.code === "TIMEOUT") {
+    return "Blockchain request timed out. Please try again.";
+  }
+  if (message.includes("network mismatch")) {
+    return "Please switch to the correct blockchain network in your wallet.";
+  }
+  if (error.code === "INVALID_ARGUMENT") {
+    return "Invalid argument passed to a blockchain function.";
+  }
+  if (error.code === "MISSING_ARGUMENT") {
+    return "Missing required argument for blockchain call.";
+  }
+  if (error.code === "UNEXPECTED_ARGUMENT") {
+    return "Unexpected argument passed to blockchain function.";
+  }
+  if (error.code === "VALUE_MISMATCH") {
+    return "Provided values do not match the expected format.";
+  }
+  if (error.code === "BAD_DATA") {
+    return "Received malformed data from the blockchain.";
+  }
+  if (error.code === "BUFFER_OVERRUN") {
+    return "Data buffer overflow occurred while decoding blockchain response.";
+  }
+  if (error.code === "NUMERIC_FAULT") {
+    return "Numeric overflow or underflow occurred.";
+  }
+  if (error.code === "NOT_IMPLEMENTED") {
+    return "This blockchain operation is not implemented.";
+  }
+  if (error.code === "UNSUPPORTED_OPERATION") {
+    return "This operation is not supported by the current provider.";
+  }
+  if (error.code === "UNCONFIGURED_NAME") {
+    return "ENS name is not configured correctly.";
+  }
+  if (error.code === "OFFCHAIN_FAULT") {
+    return "Off-chain data lookup failed.";
+  }
+  if (error.code === "UNKNOWN_ERROR") {
+    return "An unknown blockchain error occurred.";
+  }
+  return error.reason || error.message || "An unexpected blockchain error occurred.";
+};
+
+// src/store/evm.store.ts
+function createEvmStore(config) {
+  let state = getInitialState();
+  const listeners = /* @__PURE__ */ new Set();
+  const getState = () => state;
+  const subscribe = (onStoreChange) => {
+    listeners.add(onStoreChange);
+    return () => {
+      listeners.delete(onStoreChange);
+    };
+  };
+  const setState = (partial) => {
+    const next = typeof partial === "function" ? partial(state) : { ...state, ...partial };
+    if (next !== state) {
+      state = next;
+      listeners.forEach((listener) => listener());
+    }
+  };
+  const getProvider = () => {
+    if (state._signer) return state._signer.provider;
+    if (state._provider) return state._provider;
+    if (config.rpcUrl) {
+      const provider = config.rpcUrl.startsWith("wss") ? new ethers.WebSocketProvider(config.rpcUrl) : new ethers.JsonRpcProvider(config.rpcUrl);
+      setState({ _provider: provider });
+      return provider;
+    }
+    if (typeof window !== "undefined" && window.ethereum) {
+      const provider = new ethers.BrowserProvider(window.ethereum);
+      setState({ _provider: provider });
+      return provider;
+    }
+    throwError(
+      "getProvider: No provider available (no wallet connected, no RPC URL, and no injected provider)"
+    );
+  };
+  const getSigner = () => {
+    if (state._signer) return state._signer;
+    if (config.rpcUrl) {
+      const provider = new ethers.JsonRpcProvider(config.rpcUrl);
+      const wallet = ethers.Wallet.createRandom().connect(provider);
+      setState({ _signer: wallet });
+      return wallet;
+    }
+    throwError("getSigner: No signer available");
+  };
+  const getContract = (forWrite = false) => {
+    const signerOrProvider = forWrite ? getSigner() : getProvider();
+    if (state._contract && state._contract.runner === signerOrProvider) {
+      return state._contract;
+    }
+    const contract = new ethers.Contract(
+      config.address,
+      config.abi,
+      signerOrProvider
+    );
+    setState({ _contract: contract });
+    return contract;
+  };
+  const queryRegistry = /* @__PURE__ */ new Map();
+  const queryFn = async (functionName, args) => {
+    const safeArgs = JSON.stringify(
+      args,
+      (_, value) => typeof value === "bigint" ? value.toString() : value
+    );
+    const queryKey = `${functionName}:${safeArgs}`;
+    const execute = async () => {
+      try {
+        const contract = getContract(false);
+        const result = await contract[functionName](...args);
+        return { data: result };
+      } catch (error) {
+        return { error: new Error(mapEthersError(error)) };
+      }
+    };
+    queryRegistry.set(queryKey, async () => {
+      await execute();
+    });
+    return execute();
+  };
+  const invalidate = (functionName) => {
+    queryRegistry.forEach((refresh, key) => {
+      if (key.startsWith(`${functionName}:`)) {
+        refresh();
+      }
+    });
+  };
+  const mutateFn = async (functionName, args) => {
+    if (!state.wallet.isConnected)
+      return { error: new Error("mutateFn: Wallet not connected") };
+    const targetChain = config.chains.find(
+      (c) => c.id === state.wallet.chainId
+    );
+    if (!targetChain) {
+      return {
+        error: new Error(
+          `targetChain: Chain ${state.wallet.chainId} not supported`
+        )
+      };
+    }
+    try {
+      const contract = getContract(true);
+      const tx = await contract[functionName](...args);
+      const receipt = await tx.wait();
+      return { data: { hash: tx.hash, receipt } };
+    } catch (error) {
+      return { error: new Error(mapEthersError(error)) };
+    }
+  };
+  const listenFn = (eventName, listener) => {
+    let contract = getContract(false);
+    let cleanupFallback;
+    const startListening = async () => {
+      try {
+        await contract.on(eventName, listener);
+      } catch (error) {
+        const isRpcRestriction = error.message.includes("eth_newFilter") || error.message.includes("whitelisted");
+        if (isRpcRestriction) {
+          console.warn(`Polling fallback for event: ${eventName}`);
+          cleanupFallback = createEventPoller(
+            {
+              provider: getProvider(),
+              contract,
+              eventName
+            },
+            listener
+          );
+        } else {
+          console.error("Failed to set up event listener:", error);
+        }
+      }
+    };
+    startListening();
+    return () => {
+      contract.off(eventName, listener);
+      if (cleanupFallback) cleanupFallback();
+    };
+  };
+  return {
+    getState,
+    setState,
+    subscribe,
+    queryFn,
+    invalidate,
+    mutateFn,
+    listenFn
+  };
+}
+
+// src/factory/create.tsx
+import { Fragment, jsx } from "react/jsx-runtime";
+function create(config) {
+  const store = createEvmStore(config);
+  let kitPromise = null;
+  const getKit = () => {
+    if (kitPromise) return kitPromise;
+    kitPromise = (async () => {
+      const kit = config.kit;
+      const bridgeProps = {
+        onConnect: (address, chainId, signer) => {
+          store.setState({
+            wallet: {
+              ...store.getState().wallet,
+              isConnected: true,
+              isConnecting: false,
+              address,
+              chainId
+            },
+            _signer: signer,
+            _provider: signer.provider,
+            _contract: void 0
+          });
+        },
+        onDisconnect: () => {
+          store.setState({
+            wallet: {
+              ...store.getState().wallet,
+              isConnected: false,
+              address: void 0,
+              chainId: void 0
+            },
+            _signer: void 0,
+            _contract: void 0
+          });
+        }
+      };
+      if (kit.name === "connectkit") {
+        const { createConnectkitProvider } = await import("./connectkit.provider-6R2D3NSB.mjs");
+        return createConnectkitProvider(
+          kit,
+          config.chains,
+          config.rpcUrl || "",
+          bridgeProps
+        );
+      } else if (kit.name === "reown") {
+        const { createReownProvider } = await import("./reown.provider-QWD2VLQQ.mjs");
+        return createReownProvider(
+          kit,
+          config.chains,
+          config.rpcUrl || "",
+          bridgeProps
+        );
+      }
+    })();
+    return kitPromise;
+  };
+  const call = {
+    // Query (view/pure) – args as tuple
+    queryFn: (functionName, args) => {
+      return store.queryFn(functionName, [...args]);
+    },
+    // Mutation (nonpayable/payable) – args as tuple
+    mutateFn: (functionName, args) => {
+      return store.mutateFn(functionName, [...args]);
+    },
+    // Event listener – args are spread naturally
+    listenFn: (eventName, listener) => {
+      return store.listenFn(eventName, listener);
+    }
+  };
+  const Provider = ({ children }) => {
+    const [KitProvider, setKitProvider] = React.useState(null);
+    React.useEffect(() => {
+      getKit().then((kitInstance) => {
+        if (kitInstance) {
+          setKitProvider(() => kitInstance.Provider);
+        }
+      });
+    }, []);
+    if (config.kit && !KitProvider) {
+      return null;
+    }
+    if (KitProvider) {
+      return /* @__PURE__ */ jsx(KitProvider, { children });
+    }
+    return /* @__PURE__ */ jsx(Fragment, { children });
+  };
+  const ConnectButton = ({ children, ...props }) => {
+    const [KitButton, setKitButton] = React.useState(
+      null
+    );
+    React.useEffect(() => {
+      getKit().then((kitInstance) => {
+        if (kitInstance) {
+          setKitButton(() => kitInstance.ConnectButton);
+        }
+      });
+    }, []);
+    if (config.kit && !KitButton) return null;
+    if (KitButton) return /* @__PURE__ */ jsx(KitButton, { ...props, children });
+    return null;
+  };
+  function useStore() {
+    const state = useSyncExternalStore(
+      store.subscribe,
+      store.getState,
+      () => store.getState()
+      // SSR Snapshot for Next.js
+    );
+    return {
+      call,
+      web3Provider: state.provider,
+      wallet: {
+        account: state.wallet
+      }
+    };
+  }
+  useStore.call = call;
+  useStore.getState = store.getState;
+  useStore.subscribe = store.subscribe;
+  useStore.Provider = Provider;
+  useStore.ConnectButton = ConnectButton;
+  return useStore;
+}
+
+// src/utils/formatter.ts
+import { ethers as ethers2 } from "ethers";
+var fromWei = (value, decimals = 18) => ethers2.formatUnits(value.toString(), decimals);
+var toWei = (value, decimals = 18) => ethers2.parseUnits(value, decimals);
+function formatAddress(address, options) {
+  if (!address) throwError("formatAddress: address is required");
+  const endChars = options?.endChars ?? 6;
+  const separator = options?.separator ?? "...";
+  const position = options?.position ?? "middle";
+  const start = address.slice(0, 4);
+  const end = address.slice(-endChars);
+  if (position === "end") {
+    return `${start}${separator}`;
+  }
+  return `${start}${separator}${end}`;
+}
+export {
+  EvmChains,
+  create,
+  createEventPoller,
+  formatAddress,
+  fromWei,
+  mapEthersError,
+  throwError,
+  toWei
+};

package/dist/reown.provider-QWD2VLQQ.mjs

@@ -0,0 +1,80 @@
+"use client";
+import {
+  KitBridge
+} from "./chunk-I6Z24RI3.mjs";
+
+// src/components/providers/reown.provider.tsx
+import React from "react";
+import { WagmiProvider } from "wagmi";
+import { QueryClient, QueryClientProvider } from "@tanstack/react-query";
+import { createAppKit, useAppKit } from "@reown/appkit/react";
+import { useAccount } from "wagmi";
+import { WagmiAdapter } from "@reown/appkit-adapter-wagmi";
+import { Fragment, jsx, jsxs } from "react/jsx-runtime";
+function createReownProvider(kitConfig, chains, rpcUrl, bridgeProps) {
+  const wagmiAdapter = new WagmiAdapter({
+    networks: chains,
+    projectId: kitConfig.config.projectId,
+    ssr: kitConfig.config.ssr
+  });
+  const metadata = {
+    ...kitConfig.config.metadata,
+    url: typeof window !== "undefined" && window.location.hostname === "localhost" ? window.location.origin : kitConfig.config.metadata.url
+  };
+  if (typeof window !== "undefined") {
+    createAppKit({
+      adapters: [wagmiAdapter],
+      networks: chains,
+      projectId: kitConfig.config.projectId,
+      metadata,
+      features: {
+        analytics: true
+      }
+    });
+  }
+  const queryClient = new QueryClient();
+  const Provider = ({ children }) => /* @__PURE__ */ jsx(WagmiProvider, { config: wagmiAdapter.wagmiConfig, children: /* @__PURE__ */ jsxs(QueryClientProvider, { client: queryClient, children: [
+    /* @__PURE__ */ jsx(KitBridge, { ...bridgeProps }),
+    children
+  ] }) });
+  const ConnectButton = ({
+    children,
+    ...props
+  }) => {
+    const { open: reownOpen, close } = useAppKit();
+    const { address, isConnected, isConnecting, chainId } = useAccount();
+    const open = React.useCallback(async () => {
+      try {
+        await reownOpen();
+      } catch (e) {
+        console.error("AppKit open error, retrying...", e);
+      }
+    }, [reownOpen]);
+    if (children) {
+      return /* @__PURE__ */ jsx(Fragment, { children: children({
+        isConnected,
+        isConnecting,
+        address,
+        ensName: null,
+        // AppKit doesn't expose ENS directly in useAccount easily without extra hooks
+        chain: chainId ? { id: chainId } : void 0,
+        open,
+        close
+      }) });
+    }
+    return (
+      // @ts-ignore
+      /* @__PURE__ */ jsx(
+        "appkit-button",
+        {
+          label: props.label,
+          balance: props.showBalance ? "show" : "hide"
+        }
+      )
+    );
+  };
+  return { Provider, ConnectButton };
+}
+export {
+  createReownProvider
+};

package/package.json

@@ -0,0 +1,47 @@
+{
+  "name": "@trezo/evm",
+  "description": "A high-performance, type-safe EVM state orchestration layer for modern Web3 applications.",
+  "version": "0.1.0",
+  "author": "thelastofinusa",
+  "license": "MIT",
+  "main": "./dist/index.js",
+  "module": "./dist/index.mjs",
+  "types": "./dist/index.d.ts",
+  "scripts": {
+    "build": "tsup src/index.ts --format esm,cjs --dts",
+    "prepublishOnly": "npm run build",
+    "genokit": "tsx scripts/genokit.ts",
+    "typecheck": "tsc --noEmit",
+    "publish-package": "npm publish --access public"
+  },
+  "files": [
+    "dist/**/*.js",
+    "dist/**/*.mjs",
+    "dist/**/*.d.ts",
+    "dist/**/*.d.mts",
+    "LICENSE",
+    "README.md"
+  ],
+  "peerDependencies": {
+    "react": ">=17.0.0",
+    "react-dom": ">=17.0.0"
+  },
+  "dependencies": {
+    "@reown/appkit": "^1.6.8",
+    "@reown/appkit-adapter-wagmi": "^1.6.8",
+    "@tanstack/react-query": "^5.90.21",
+    "abitype": "^1.2.3",
+    "connectkit": "^1.9.1",
+    "ethers": "^6.16.0",
+    "viem": "^2.21.0",
+    "wagmi": "^2.14.9"
+  },
+  "devDependencies": {
+    "@metamask/providers": "^22.1.1",
+    "@types/node": "^25.5.0",
+    "@types/react": "^19",
+    "tsup": "^8.5.1",
+    "tsx": "^4.21.0",
+    "typescript": "^5.9.3"
+  }
+}