@trezo/evm 0.1.0

package/dist/index.js

@@ -0,0 +1,665 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/components/KitBridge.tsx
+function KitBridge({
+  onConnect,
+  onDisconnect
+}) {
+  const { address, chainId, isConnected } = (0, import_wagmi.useAccount)();
+  const { data: walletClient } = (0, import_wagmi.useWalletClient)();
+  (0, import_react.useEffect)(() => {
+    if (!isConnected || !address || !chainId || !walletClient) {
+      onDisconnect();
+      return;
+    }
+    const provider = new import_ethers2.ethers.BrowserProvider(walletClient);
+    provider.getSigner().then((signer) => {
+      onConnect(address, chainId, signer);
+    });
+  }, [isConnected, address, chainId, walletClient]);
+  return null;
+}
+var import_react, import_wagmi, import_ethers2;
+var init_KitBridge = __esm({
+  "src/components/KitBridge.tsx"() {
+    "use strict";
+    "use client";
+    import_react = require("react");
+    import_wagmi = require("wagmi");
+    import_ethers2 = require("ethers");
+  }
+});
+
+// src/components/providers/connectkit.provider.tsx
+var connectkit_provider_exports = {};
+__export(connectkit_provider_exports, {
+  createConnectkitProvider: () => createConnectkitProvider
+});
+function createConnectkitProvider(kitConfig, chains, rpcUrl, bridgeProps) {
+  const wagmiConfig = (0, import_wagmi2.createConfig)(
+    (0, import_connectkit.getDefaultConfig)({
+      chains,
+      transports: Object.fromEntries(chains.map((c) => [c.id, (0, import_wagmi2.http)(rpcUrl)])),
+      walletConnectProjectId: kitConfig.config.projectId,
+      appName: kitConfig.config.metadata.appName,
+      appDescription: kitConfig.config.metadata.appDescription,
+      appUrl: kitConfig.config.metadata.appUrl,
+      appIcon: kitConfig.config.metadata.appIcon
+    })
+  );
+  const queryClient = new import_react_query.QueryClient();
+  const Provider = ({ children }) => /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_wagmi2.WagmiProvider, { config: wagmiConfig, children: /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_react_query.QueryClientProvider, { client: queryClient, children: /* @__PURE__ */ (0, import_jsx_runtime.jsxs)(import_connectkit.ConnectKitProvider, { children: [
+    /* @__PURE__ */ (0, import_jsx_runtime.jsx)(KitBridge, { ...bridgeProps }),
+    children
+  ] }) }) });
+  const ConnectButton = ({
+    children,
+    ...props
+  }) => {
+    if (children) {
+      return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_connectkit.ConnectKitButton.Custom, { children: ({
+        isConnected,
+        isConnecting,
+        show,
+        hide,
+        address,
+        ensName,
+        chain
+      }) => children({
+        isConnected,
+        isConnecting,
+        address,
+        ensName,
+        chain,
+        open: show ?? (() => {
+        }),
+        close: hide ?? (() => {
+        })
+      }) });
+    }
+    return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_connectkit.ConnectKitButton, { ...props });
+  };
+  return { Provider, ConnectButton };
+}
+var import_wagmi2, import_react_query, import_connectkit, import_jsx_runtime;
+var init_connectkit_provider = __esm({
+  "src/components/providers/connectkit.provider.tsx"() {
+    "use strict";
+    "use client";
+    import_wagmi2 = require("wagmi");
+    import_react_query = require("@tanstack/react-query");
+    import_connectkit = require("connectkit");
+    init_KitBridge();
+    import_jsx_runtime = require("react/jsx-runtime");
+  }
+});
+
+// src/components/providers/reown.provider.tsx
+var reown_provider_exports = {};
+__export(reown_provider_exports, {
+  createReownProvider: () => createReownProvider
+});
+function createReownProvider(kitConfig, chains, rpcUrl, bridgeProps) {
+  const wagmiAdapter = new import_appkit_adapter_wagmi.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") {
+    (0, import_react3.createAppKit)({
+      adapters: [wagmiAdapter],
+      networks: chains,
+      projectId: kitConfig.config.projectId,
+      metadata,
+      features: {
+        analytics: true
+      }
+    });
+  }
+  const queryClient = new import_react_query2.QueryClient();
+  const Provider = ({ children }) => /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(import_wagmi3.WagmiProvider, { config: wagmiAdapter.wagmiConfig, children: /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)(import_react_query2.QueryClientProvider, { client: queryClient, children: [
+    /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(KitBridge, { ...bridgeProps }),
+    children
+  ] }) });
+  const ConnectButton = ({
+    children,
+    ...props
+  }) => {
+    const { open: reownOpen, close } = (0, import_react3.useAppKit)();
+    const { address, isConnected, isConnecting, chainId } = (0, import_wagmi4.useAccount)();
+    const open = import_react2.default.useCallback(async () => {
+      try {
+        await reownOpen();
+      } catch (e) {
+        console.error("AppKit open error, retrying...", e);
+      }
+    }, [reownOpen]);
+    if (children) {
+      return /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(import_jsx_runtime2.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__ */ (0, import_jsx_runtime2.jsx)(
+        "appkit-button",
+        {
+          label: props.label,
+          balance: props.showBalance ? "show" : "hide"
+        }
+      )
+    );
+  };
+  return { Provider, ConnectButton };
+}
+var import_react2, import_wagmi3, import_react_query2, import_react3, import_wagmi4, import_appkit_adapter_wagmi, import_jsx_runtime2;
+var init_reown_provider = __esm({
+  "src/components/providers/reown.provider.tsx"() {
+    "use strict";
+    "use client";
+    import_react2 = __toESM(require("react"));
+    import_wagmi3 = require("wagmi");
+    import_react_query2 = require("@tanstack/react-query");
+    import_react3 = require("@reown/appkit/react");
+    import_wagmi4 = require("wagmi");
+    import_appkit_adapter_wagmi = require("@reown/appkit-adapter-wagmi");
+    init_KitBridge();
+    import_jsx_runtime2 = require("react/jsx-runtime");
+  }
+});
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  EvmChains: () => EvmChains,
+  create: () => create,
+  createEventPoller: () => createEventPoller,
+  formatAddress: () => formatAddress,
+  fromWei: () => fromWei,
+  mapEthersError: () => mapEthersError,
+  throwError: () => throwError,
+  toWei: () => toWei
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/types/config.ts
+var Chains = __toESM(require("viem/chains"));
+var EvmChains = Chains;
+
+// src/factory/create.tsx
+var import_react4 = __toESM(require("react"));
+
+// src/store/evm.store.ts
+var import_ethers = require("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 import_ethers.ethers.WebSocketProvider(config.rpcUrl) : new import_ethers.ethers.JsonRpcProvider(config.rpcUrl);
+      setState({ _provider: provider });
+      return provider;
+    }
+    if (typeof window !== "undefined" && window.ethereum) {
+      const provider = new import_ethers.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 import_ethers.ethers.JsonRpcProvider(config.rpcUrl);
+      const wallet = import_ethers.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 import_ethers.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
+var import_jsx_runtime3 = require("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: createConnectkitProvider2 } = await Promise.resolve().then(() => (init_connectkit_provider(), connectkit_provider_exports));
+        return createConnectkitProvider2(
+          kit,
+          config.chains,
+          config.rpcUrl || "",
+          bridgeProps
+        );
+      } else if (kit.name === "reown") {
+        const { createReownProvider: createReownProvider2 } = await Promise.resolve().then(() => (init_reown_provider(), reown_provider_exports));
+        return createReownProvider2(
+          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] = import_react4.default.useState(null);
+    import_react4.default.useEffect(() => {
+      getKit().then((kitInstance) => {
+        if (kitInstance) {
+          setKitProvider(() => kitInstance.Provider);
+        }
+      });
+    }, []);
+    if (config.kit && !KitProvider) {
+      return null;
+    }
+    if (KitProvider) {
+      return /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(KitProvider, { children });
+    }
+    return /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(import_jsx_runtime3.Fragment, { children });
+  };
+  const ConnectButton = ({ children, ...props }) => {
+    const [KitButton, setKitButton] = import_react4.default.useState(
+      null
+    );
+    import_react4.default.useEffect(() => {
+      getKit().then((kitInstance) => {
+        if (kitInstance) {
+          setKitButton(() => kitInstance.ConnectButton);
+        }
+      });
+    }, []);
+    if (config.kit && !KitButton) return null;
+    if (KitButton) return /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(KitButton, { ...props, children });
+    return null;
+  };
+  function useStore() {
+    const state = (0, import_react4.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
+var import_ethers3 = require("ethers");
+var fromWei = (value, decimals = 18) => import_ethers3.ethers.formatUnits(value.toString(), decimals);
+var toWei = (value, decimals = 18) => import_ethers3.ethers.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}`;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  EvmChains,
+  create,
+  createEventPoller,
+  formatAddress,
+  fromWei,
+  mapEthersError,
+  throwError,
+  toWei
+});