@hfunlabs/hypurr-connect 0.1.1 → 0.1.3

package/dist/index.js

@@ -1,20 +1,21 @@
 // src/HypurrConnectProvider.tsx
 import {
   ExchangeClient,
-  HttpTransport,
-  InfoClient
+  HttpTransport
 } from "@hfunlabs/hyperliquid";
-import { PrivateKeySigner } from "@hfunlabs/hyperliquid/signing";
+import { PrivateKeySigner, signUserSignedAction } from "@hfunlabs/hyperliquid/signing";
 import {
   createContext,
   useCallback,
   useContext,
   useEffect,
   useMemo,
+  useRef,
   useState
 } from "react";
 
 // src/agent.ts
+var AGENT_NAME = "hypurr-connect";
 var AGENT_STORAGE_PREFIX = "hypurr-connect-agent";
 function storageKey(masterAddress) {
   return `${AGENT_STORAGE_PREFIX}:${masterAddress.toLowerCase()}`;
@@ -41,6 +42,39 @@ async function generateAgentKey() {
   const signer = new PrivateKeySigner2(privateKey);
   return { privateKey, address: signer.address };
 }
+async function fetchActiveAgent(userAddress, isTestnet) {
+  const url = isTestnet ? "https://api.hyperliquid-testnet.xyz/info" : "https://api.hyperliquid.xyz/info";
+  const res = await fetch(url, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({ type: "extraAgents", user: userAddress })
+  });
+  if (!res.ok) return null;
+  const agents = await res.json();
+  if (!Array.isArray(agents)) return null;
+  const nowMs = Date.now();
+  const match = agents.find(
+    (a) => a.name === AGENT_NAME && a.validUntil * 1e3 > nowMs
+  );
+  if (!match) return null;
+  return { ...match, validUntil: match.validUntil * 1e3 };
+}
+async function isAgentValid(stored, userAddress, isTestnet) {
+  if (stored.validUntil <= Date.now()) return false;
+  const remote = await fetchActiveAgent(userAddress, isTestnet);
+  if (!remote) return false;
+  return remote.address.toLowerCase() === stored.address.toLowerCase() && remote.validUntil > Date.now();
+}
+var DEAD_AGENT_PATTERNS = [
+  /agent address .+ is not valid/i,
+  /unknown signer/i,
+  /not authorized/i,
+  /not an agent/i
+];
+function isDeadAgentError(err) {
+  const msg = err instanceof Error ? err.message : typeof err === "object" && err !== null && "message" in err ? String(err.message) : String(err);
+  return DEAD_AGENT_PATTERNS.some((p) => p.test(msg));
+}
 
 // src/grpc.ts
 import { GrpcWebFetchTransport } from "@protobuf-ts/grpcweb-transport";
@@ -152,6 +186,14 @@ function useHypurrConnect() {
     );
   return ctx;
 }
+function useHypurrConnectInternal() {
+  const ctx = useContext(HypurrConnectContext);
+  if (!ctx)
+    throw new Error(
+      "useHypurrConnectInternal must be used within <HypurrConnectProvider>"
+    );
+  return ctx;
+}
 function HypurrConnectProvider({
   config,
   children
@@ -175,6 +217,7 @@ function HypurrConnectProvider({
     () => tgLoginData ? toAuthDataMap(tgLoginData) : {},
     [tgLoginData]
   );
+  const [tgUserTick, setTgUserTick] = useState(0);
   useEffect(() => {
     if (!tgLoginData) return;
     let cancelled = false;
@@ -183,9 +226,7 @@ function HypurrConnectProvider({
     (async () => {
       try {
         const authData = toAuthDataMap(tgLoginData);
-        console.log(authData);
         const { response } = await tgClient.telegramUser({ authData });
-        console.log(response);
         if (cancelled) return;
         setTgUser(response.user ?? null);
       } catch (err) {
@@ -199,27 +240,56 @@ function HypurrConnectProvider({
     return () => {
       cancelled = true;
     };
-  }, [tgLoginData, tgClient]);
+  }, [tgLoginData, tgClient, tgUserTick]);
   const [eoaAddress, setEoaAddress] = useState(null);
   const [agent, setAgent] = useState(null);
+  const [eoaLoading, setEoaLoading] = useState(false);
+  const [eoaError, setEoaError] = useState(null);
+  const eoaSignerRef = useRef(null);
+  const authMethod = tgLoginData ? "telegram" : eoaAddress ? "eoa" : null;
+  const [wallets, setWallets] = useState([]);
+  const [selectedWalletId, setSelectedWalletId] = useState(0);
+  const [packs, setPacks] = useState([]);
+  const refreshWallets = useCallback(() => setTgUserTick((t) => t + 1), []);
   useEffect(() => {
-    if (eoaAddress) {
-      setAgent(loadAgent(eoaAddress));
-    } else {
-      setAgent(null);
+    if (authMethod !== "telegram" || !tgUser) {
+      setWallets([]);
+      setSelectedWalletId(0);
+      setPacks([]);
+      return;
     }
-  }, [eoaAddress]);
-  const authMethod = tgLoginData ? "telegram" : eoaAddress ? "eoa" : null;
-  const tgWallet = tgUser?.wallet ?? (tgUser?.wallets ?? [])[0] ?? null;
+    const userWallets = tgUser.wallets ?? [];
+    setWallets(userWallets);
+    setPacks(tgUser.packs ?? []);
+    const defaultId = tgUser.walletId || userWallets[0]?.id || 0;
+    setSelectedWalletId((prev) => {
+      if (prev && userWallets.some((w) => w.id === prev)) return prev;
+      return defaultId;
+    });
+  }, [authMethod, tgUser]);
+  const selectedWallet = useMemo(
+    () => wallets.find((w) => w.id === selectedWalletId) ?? wallets[0] ?? null,
+    [wallets, selectedWalletId]
+  );
+  const selectWallet = useCallback(
+    (walletId) => {
+      if (wallets.some((w) => w.id === walletId)) {
+        setSelectedWalletId(walletId);
+      }
+    },
+    [wallets]
+  );
   const user = useMemo(() => {
-    if (tgLoginData && authMethod === "telegram") {
+    if (tgLoginData && authMethod === "telegram" && selectedWallet) {
       return {
-        address: tgWallet?.ethereumAddress ?? "",
-        walletId: tgUser?.walletId ?? tgWallet?.id ?? 0,
+        address: selectedWallet.ethereumAddress,
+        walletId: selectedWallet.id,
         displayName: tgLoginData.username ? `@${tgLoginData.username}` : tgLoginData.first_name,
         photoUrl: tgLoginData.photo_url,
         authMethod: "telegram",
-        telegramId: String(tgLoginData.id)
+        telegramId: String(tgLoginData.id),
+        hfunScore: tgUser?.reputation?.hfunScore,
+        reputationScore: tgUser?.reputation?.reputationScore
       };
     }
     if (eoaAddress && authMethod === "eoa") {
@@ -231,7 +301,23 @@ function HypurrConnectProvider({
       };
     }
     return null;
-  }, [tgLoginData, tgUser, tgWallet, eoaAddress, authMethod]);
+  }, [tgLoginData, selectedWallet, eoaAddress, authMethod, tgUser]);
+  const onDeadAgentRef = useRef(
+    null
+  );
+  onDeadAgentRef.current = (addr) => {
+    clearAgent(addr);
+    setAgent(null);
+    setEoaError("Agent expired or was deregistered. Please reconnect.");
+  };
+  const agentSignerRef = useRef(
+    agent ? new PrivateKeySigner(agent.privateKey) : null
+  );
+  useEffect(() => {
+    agentSignerRef.current = agent ? new PrivateKeySigner(agent.privateKey) : null;
+  }, [agent]);
+  const provisioningRef = useRef(null);
+  const agentReady = authMethod === "telegram" || authMethod === "eoa" && !!agent;
   const exchange = useMemo(() => {
     if (authMethod === "telegram" && user?.address) {
       const transport = new GrpcExchangeTransport({
@@ -246,127 +332,229 @@ function HypurrConnectProvider({
         userAddress: user.address
       });
     }
-    if (authMethod === "eoa" && agent) {
-      const wallet = new PrivateKeySigner(agent.privateKey);
-      return new ExchangeClient({
-        transport: new HttpTransport({
-          isTestnet: config.isTestnet ?? false
-        }),
-        wallet
-      });
-    }
-    return null;
-  }, [authMethod, user, agent, config.isTestnet, tgClient, authDataMap]);
-  const infoClient = useMemo(
-    () => new InfoClient({
-      transport: new HttpTransport({
-        isTestnet: config.isTestnet ?? false
-      })
-    }),
-    [config.isTestnet]
-  );
-  const [usdcBalance, setUsdcBalance] = useState(null);
-  const [usdcBalanceLoading, setUsdcBalanceLoading] = useState(false);
-  const [balanceTick, setBalanceTick] = useState(0);
-  const refreshBalance = useCallback(() => setBalanceTick((t) => t + 1), []);
-  useEffect(() => {
-    const addr = user?.address;
-    if (!addr) {
-      setUsdcBalance(null);
-      return;
-    }
-    let cancelled = false;
-    setUsdcBalanceLoading(true);
-    (async () => {
-      try {
-        const state = await infoClient.clearinghouseState({
-          user: addr
+    if (authMethod === "eoa" && eoaAddress) {
+      const hasSigner = !!eoaSignerRef.current;
+      if (!agent && !hasSigner) {
+        const noAgentTransport = {
+          isTestnet: config.isTestnet ?? false,
+          request() {
+            throw new Error(
+              "[HypurrConnect] No agent key approved and no wallet signer available. Either call approveAgent(signTypedDataAsync) or pass a signer to connectEoa(address, { signTypedData, chainId })."
+            );
+          }
+        };
+        return new ExchangeClient({
+          transport: noAgentTransport,
+          externalSigning: true,
+          userAddress: eoaAddress
         });
-        if (!cancelled) {
-          setUsdcBalance(state.withdrawable);
-        }
-      } catch (err) {
-        console.error("[HypurrConnect] Failed to fetch USDC balance:", err);
-        if (!cancelled) setUsdcBalance(null);
-      } finally {
-        if (!cancelled) setUsdcBalanceLoading(false);
       }
-    })();
-    return () => {
-      cancelled = true;
-    };
-  }, [user?.address, infoClient, balanceTick]);
-  const approveAgent = useCallback(
-    async (signTypedDataAsync) => {
-      if (!eoaAddress) throw new Error("No EOA address connected");
-      const { privateKey, address: agentAddress } = await generateAgentKey();
       const isTestnet = config.isTestnet ?? false;
-      const nonce = Date.now();
-      const action = {
-        type: "approveAgent",
-        signatureChainId: isTestnet ? "0x66eee" : "0xa4b1",
-        hyperliquidChain: isTestnet ? "Testnet" : "Mainnet",
-        agentAddress: agentAddress.toLowerCase(),
-        agentName: null,
-        nonce
+      const inner = new HttpTransport({ isTestnet });
+      const deadAgentAddr = eoaAddress;
+      const guardedTransport = {
+        isTestnet: inner.isTestnet,
+        async request(endpoint, payload, signal) {
+          try {
+            return await inner.request(endpoint, payload, signal);
+          } catch (err) {
+            if (endpoint === "exchange" && isDeadAgentError(err)) {
+              onDeadAgentRef.current?.(deadAgentAddr);
+            }
+            throw err;
+          }
+        }
       };
-      const types = {
-        "HyperliquidTransaction:ApproveAgent": [
-          { name: "hyperliquidChain", type: "string" },
-          { name: "agentAddress", type: "address" },
-          { name: "agentName", type: "string" },
-          { name: "nonce", type: "uint64" }
-        ]
+      const signerRef = eoaSignerRef;
+      const agentRef = agentSignerRef;
+      const provRef = provisioningRef;
+      const ownerAddress = eoaAddress;
+      const ensureAgent = async () => {
+        const existing = agentRef.current;
+        if (existing) return existing;
+        if (provRef.current) return provRef.current;
+        const signer = signerRef.current;
+        if (!signer) {
+          throw new Error(
+            "[HypurrConnect] No wallet signer available to auto-provision agent. Pass a signer to connectEoa(address, { signTypedData, chainId })."
+          );
+        }
+        provRef.current = (async () => {
+          try {
+            const { privateKey, address: agentAddress } = await generateAgentKey();
+            const chainIdHex = `0x${signer.chainId.toString(16)}`;
+            const nonce = Date.now();
+            const action = {
+              type: "approveAgent",
+              signatureChainId: chainIdHex,
+              hyperliquidChain: isTestnet ? "Testnet" : "Mainnet",
+              agentAddress: agentAddress.toLowerCase(),
+              agentName: AGENT_NAME,
+              nonce
+            };
+            const approveAgentTypes = {
+              "HyperliquidTransaction:ApproveAgent": [
+                { name: "hyperliquidChain", type: "string" },
+                { name: "agentAddress", type: "address" },
+                { name: "agentName", type: "string" },
+                { name: "nonce", type: "uint64" }
+              ]
+            };
+            const wallet = {
+              // eslint-disable-next-line @typescript-eslint/no-explicit-any
+              signTypedData(params) {
+                return signer.signTypedData(params);
+              },
+              getAddresses: async () => [ownerAddress],
+              getChainId: async () => signer.chainId
+            };
+            const signature = await signUserSignedAction({
+              wallet,
+              action,
+              types: approveAgentTypes
+            });
+            const apiUrl = isTestnet ? "https://api.hyperliquid-testnet.xyz/exchange" : "https://api.hyperliquid.xyz/exchange";
+            const res = await fetch(apiUrl, {
+              method: "POST",
+              headers: { "Content-Type": "application/json" },
+              body: JSON.stringify({ action, signature, nonce })
+            });
+            const body = await res.json();
+            if (body?.status === "err") {
+              throw new Error(
+                `approveAgent API error: ${body.response ?? JSON.stringify(body)}`
+              );
+            }
+            const remote = await fetchActiveAgent(ownerAddress, isTestnet);
+            const validUntil = remote?.validUntil ?? Date.now() + 7 * 24 * 60 * 60 * 1e3;
+            const stored = {
+              privateKey,
+              address: agentAddress,
+              approvedAt: Date.now(),
+              validUntil
+            };
+            saveAgent(ownerAddress, stored);
+            const newSigner = new PrivateKeySigner(privateKey);
+            agentRef.current = newSigner;
+            setAgent(stored);
+            return newSigner;
+          } finally {
+            provRef.current = null;
+          }
+        })();
+        return provRef.current;
       };
-      const signature = await signTypedDataAsync({
-        domain: {
-          name: "HyperliquidSignTransaction",
-          version: "1",
-          chainId: isTestnet ? 421614 : 42161,
-          verifyingContract: "0x0000000000000000000000000000000000000000"
-        },
-        types,
-        primaryType: "HyperliquidTransaction:ApproveAgent",
-        message: {
-          hyperliquidChain: action.hyperliquidChain,
-          agentAddress: action.agentAddress,
-          agentName: "",
-          nonce: BigInt(nonce)
+      const dualWallet = {
+        address: ownerAddress,
+        async signTypedData(params) {
+          if (params.domain.name === "HyperliquidSignTransaction") {
+            const signer = signerRef.current;
+            if (!signer) {
+              throw new Error(
+                "[HypurrConnect] No wallet signer available for user-signed actions. Pass a signer to connectEoa(address, { signTypedData, chainId })."
+              );
+            }
+            return signer.signTypedData(
+              params
+            );
+          }
+          const agentSigner = await ensureAgent();
+          return agentSigner.signTypedData(params);
         }
-      });
-      const r = `0x${signature.slice(2, 66)}`;
-      const s = `0x${signature.slice(66, 130)}`;
-      const v = parseInt(signature.slice(130, 132), 16);
-      const url = isTestnet ? "https://api.hyperliquid-testnet.xyz/exchange" : "https://api.hyperliquid.xyz/exchange";
-      const res = await fetch(url, {
-        method: "POST",
-        headers: { "Content-Type": "application/json" },
-        body: JSON.stringify({
-          action,
-          nonce,
-          signature: { r, s, v }
-        })
-      });
-      const body = await res.json();
-      if (body?.status !== "ok") {
-        throw new Error(`approveAgent failed: ${JSON.stringify(body)}`);
-      }
-      const stored = {
-        privateKey,
-        address: agentAddress,
-        approvedAt: Date.now()
       };
-      saveAgent(eoaAddress, stored);
-      setAgent(stored);
-    },
-    [eoaAddress, config.isTestnet]
-  );
+      return new ExchangeClient({
+        transport: guardedTransport,
+        wallet: dualWallet,
+        signatureChainId: () => {
+          const id = signerRef.current?.chainId ?? 42161;
+          return `0x${id.toString(16)}`;
+        }
+      });
+    }
+    return null;
+  }, [
+    authMethod,
+    user,
+    agent,
+    eoaAddress,
+    config.isTestnet,
+    tgClient,
+    authDataMap
+  ]);
   const handleClearAgent = useCallback(() => {
     if (eoaAddress) {
       clearAgent(eoaAddress);
       setAgent(null);
     }
   }, [eoaAddress]);
+  const createWallet = useCallback(
+    async (name) => {
+      const { response } = await tgClient.hyperliquidWalletCreate({
+        authData: authDataMap,
+        name
+      });
+      refreshWallets();
+      if (!response.wallet)
+        throw new Error("Wallet creation returned no wallet");
+      return response.wallet;
+    },
+    [tgClient, authDataMap, refreshWallets]
+  );
+  const deleteWallet = useCallback(
+    async (walletId) => {
+      await tgClient.hyperliquidWalletDelete({
+        authData: authDataMap,
+        walletId
+      });
+      if (walletId === selectedWalletId) {
+        const remaining = wallets.filter((w) => w.id !== walletId);
+        setSelectedWalletId(remaining[0]?.id ?? 0);
+      }
+      refreshWallets();
+    },
+    [tgClient, authDataMap, selectedWalletId, wallets, refreshWallets]
+  );
+  const createWalletPack = useCallback(
+    async (name) => {
+      const { response } = await tgClient.telegramChatWalletPackCreate({
+        authData: authDataMap,
+        name
+      });
+      refreshWallets();
+      return response.packId;
+    },
+    [tgClient, authDataMap, refreshWallets]
+  );
+  const addPackLabel = useCallback(
+    async (params) => {
+      await tgClient.telegramChatWalletPackLabelAdd({
+        authData: authDataMap,
+        ...params
+      });
+      refreshWallets();
+    },
+    [tgClient, authDataMap, refreshWallets]
+  );
+  const modifyPackLabel = useCallback(
+    async (params) => {
+      await tgClient.telegramChatWalletPackLabelModify({
+        authData: authDataMap,
+        ...params
+      });
+      refreshWallets();
+    },
+    [tgClient, authDataMap, refreshWallets]
+  );
+  const removePackLabel = useCallback(
+    async (params) => {
+      await tgClient.telegramChatWalletPackLabelRemove({
+        authData: authDataMap,
+        ...params
+      });
+      refreshWallets();
+    },
+    [tgClient, authDataMap, refreshWallets]
+  );
   const [loginModalOpen, setLoginModalOpen] = useState(false);
   const openLoginModal = useCallback(() => setLoginModalOpen(true), []);
   const closeLoginModal = useCallback(() => setLoginModalOpen(false), []);
@@ -375,44 +563,155 @@ function HypurrConnectProvider({
     localStorage.setItem(TELEGRAM_STORAGE_KEY, JSON.stringify(data));
     setEoaAddress(null);
     setAgent(null);
+    setEoaError(null);
   }, []);
-  const loginEoa = useCallback((address) => {
-    setEoaAddress(address);
-    setTgLoginData(null);
-    setTgUser(null);
-    setTgError(null);
-    localStorage.removeItem(TELEGRAM_STORAGE_KEY);
-  }, []);
+  const connectEoa = useCallback(
+    (address, signer) => {
+      eoaSignerRef.current = signer ?? null;
+      setEoaAddress(address);
+      setTgLoginData(null);
+      setTgUser(null);
+      setTgError(null);
+      setEoaError(null);
+      localStorage.removeItem(TELEGRAM_STORAGE_KEY);
+      const existing = loadAgent(address);
+      if (existing && existing.validUntil > Date.now()) {
+        setAgent(existing);
+      } else {
+        if (existing) clearAgent(address);
+        setAgent(null);
+      }
+    },
+    []
+  );
+  const approveAgentFn = useCallback(
+    async (signTypedDataAsync, chainId) => {
+      if (!eoaAddress) {
+        throw new Error(
+          "[HypurrConnect] Cannot approve agent: no EOA wallet connected. Call connectEoa(address) first."
+        );
+      }
+      eoaSignerRef.current = { signTypedData: signTypedDataAsync, chainId };
+      setEoaLoading(true);
+      setEoaError(null);
+      try {
+        const existing = loadAgent(eoaAddress);
+        if (existing) {
+          const isTestnet2 = config.isTestnet ?? false;
+          const valid = await isAgentValid(existing, eoaAddress, isTestnet2);
+          if (valid) {
+            setAgent(existing);
+            return;
+          }
+          clearAgent(eoaAddress);
+        }
+        const { privateKey, address: agentAddress } = await generateAgentKey();
+        const isTestnet = config.isTestnet ?? false;
+        const chainIdHex = `0x${chainId.toString(16)}`;
+        const nonce = Date.now();
+        const action = {
+          type: "approveAgent",
+          signatureChainId: chainIdHex,
+          hyperliquidChain: isTestnet ? "Testnet" : "Mainnet",
+          agentAddress: agentAddress.toLowerCase(),
+          agentName: AGENT_NAME,
+          nonce
+        };
+        const approveAgentTypes = {
+          "HyperliquidTransaction:ApproveAgent": [
+            { name: "hyperliquidChain", type: "string" },
+            { name: "agentAddress", type: "address" },
+            { name: "agentName", type: "string" },
+            { name: "nonce", type: "uint64" }
+          ]
+        };
+        const wallet = {
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          signTypedData(params) {
+            return signTypedDataAsync(params);
+          },
+          getAddresses: async () => [eoaAddress],
+          getChainId: async () => chainId
+        };
+        const signature = await signUserSignedAction({
+          wallet,
+          action,
+          types: approveAgentTypes
+        });
+        const apiUrl = isTestnet ? "https://api.hyperliquid-testnet.xyz/exchange" : "https://api.hyperliquid.xyz/exchange";
+        const res = await fetch(apiUrl, {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify({ action, signature, nonce })
+        });
+        const body = await res.json();
+        if (body?.status === "err") {
+          throw new Error(
+            `approveAgent API error: ${body.response ?? JSON.stringify(body)}`
+          );
+        }
+        const remote = await fetchActiveAgent(eoaAddress, isTestnet);
+        const validUntil = remote?.validUntil ?? Date.now() + 7 * 24 * 60 * 60 * 1e3;
+        const stored = {
+          privateKey,
+          address: agentAddress,
+          approvedAt: Date.now(),
+          validUntil
+        };
+        saveAgent(eoaAddress, stored);
+        setAgent(stored);
+      } catch (err) {
+        console.error("[HypurrConnect] EOA agent approval failed:", err);
+        setEoaError(err instanceof Error ? err.message : String(err));
+        setAgent(null);
+      } finally {
+        setEoaLoading(false);
+      }
+    },
+    [eoaAddress, config.isTestnet]
+  );
   const logout = useCallback(() => {
     setTgLoginData(null);
     setTgUser(null);
     setTgError(null);
     setEoaAddress(null);
     setAgent(null);
+    setEoaError(null);
+    eoaSignerRef.current = null;
     localStorage.removeItem(TELEGRAM_STORAGE_KEY);
   }, []);
   const value = useMemo(
     () => ({
       user,
       isLoggedIn: !!user,
-      isLoading: tgLoading,
-      error: tgError,
+      isLoading: tgLoading || eoaLoading,
+      error: tgError ?? eoaError,
       authMethod,
       exchange,
-      usdcBalance,
-      usdcBalanceLoading,
-      refreshBalance,
+      wallets,
+      selectedWalletId,
+      selectWallet,
+      createWallet,
+      deleteWallet,
+      refreshWallets,
+      packs,
+      createWalletPack,
+      addPackLabel,
+      modifyPackLabel,
+      removePackLabel,
       loginModalOpen,
       openLoginModal,
       closeLoginModal,
       loginTelegram,
-      loginEoa,
+      connectEoa,
+      approveAgent: approveAgentFn,
       logout,
       agent,
-      agentReady: authMethod === "telegram" || !!agent,
-      approveAgent,
+      agentReady,
       clearAgent: handleClearAgent,
       botId: config.telegram?.botId ?? "",
+      botUsername: config.telegram?.botUsername ?? "",
+      useWidget: config.telegram?.useWidget ?? false,
       authDataMap,
       telegramClient: tgClient,
       staticClient
@@ -420,22 +719,35 @@ function HypurrConnectProvider({
     [
       user,
       tgLoading,
+      eoaLoading,
       tgError,
+      eoaError,
       authMethod,
       exchange,
-      usdcBalance,
-      usdcBalanceLoading,
-      refreshBalance,
+      wallets,
+      selectedWalletId,
+      selectWallet,
+      createWallet,
+      deleteWallet,
+      refreshWallets,
+      packs,
+      createWalletPack,
+      addPackLabel,
+      modifyPackLabel,
+      removePackLabel,
       loginModalOpen,
       openLoginModal,
       closeLoginModal,
       loginTelegram,
-      loginEoa,
+      connectEoa,
+      approveAgentFn,
       logout,
       agent,
-      approveAgent,
+      agentReady,
       handleClearAgent,
       config.telegram?.botId,
+      config.telegram?.botUsername,
+      config.telegram?.useWidget,
       authDataMap,
       tgClient,
       staticClient
@@ -452,7 +764,7 @@ import {
 } from "framer-motion";
 import {
   useCallback as useCallback2,
-  useEffect as useEffect2,
+  useEffect as useEffect3,
   useSyncExternalStore
 } from "react";
 
@@ -583,8 +895,53 @@ function TelegramColorIcon({ style }) {
   );
 }
 
+// src/TelegramLoginWidget.tsx
+import { useEffect as useEffect2, useRef as useRef2 } from "react";
+import { jsx as jsx4 } from "react/jsx-runtime";
+var WIDGET_SCRIPT_URL = "https://telegram.org/js/telegram-widget.js?22";
+var CALLBACK_NAME = "__hypurrConnectTelegramAuth";
+function TelegramLoginWidget({
+  botUsername,
+  onAuth,
+  buttonSize = "large",
+  cornerRadius,
+  showUserPhoto = true,
+  requestAccess = true
+}) {
+  const containerRef = useRef2(null);
+  const onAuthRef = useRef2(onAuth);
+  onAuthRef.current = onAuth;
+  useEffect2(() => {
+    const container = containerRef.current;
+    if (!container) return;
+    window[CALLBACK_NAME] = (user) => {
+      onAuthRef.current(user);
+    };
+    const script = document.createElement("script");
+    script.src = WIDGET_SCRIPT_URL;
+    script.async = true;
+    script.setAttribute("data-telegram-login", botUsername);
+    script.setAttribute("data-size", buttonSize);
+    script.setAttribute("data-onauth", `${CALLBACK_NAME}(user)`);
+    script.setAttribute("data-userpic", String(showUserPhoto));
+    if (requestAccess) {
+      script.setAttribute("data-request-access", "write");
+    }
+    if (cornerRadius !== void 0) {
+      script.setAttribute("data-radius", String(cornerRadius));
+    }
+    container.innerHTML = "";
+    container.appendChild(script);
+    return () => {
+      container.innerHTML = "";
+      delete window[CALLBACK_NAME];
+    };
+  }, [botUsername, buttonSize, cornerRadius, showUserPhoto, requestAccess]);
+  return /* @__PURE__ */ jsx4("div", { ref: containerRef });
+}
+
 // src/LoginModal.tsx
-import { Fragment, jsx as jsx4, jsxs as jsxs3 } from "react/jsx-runtime";
+import { Fragment, jsx as jsx5, jsxs as jsxs3 } from "react/jsx-runtime";
 var MOBILE_BREAKPOINT = 640;
 var btnStyle = {
   display: "flex",
@@ -662,7 +1019,7 @@ function HoverButton({
   onClick,
   children
 }) {
-  return /* @__PURE__ */ jsx4(
+  return /* @__PURE__ */ jsx5(
     motion.button,
     {
       type: "button",
@@ -674,7 +1031,14 @@ function HoverButton({
   );
 }
 function LoginModal({ onConnectWallet, walletIcon }) {
-  const { loginTelegram, loginModalOpen, closeLoginModal, botId } = useHypurrConnect();
+  const {
+    loginTelegram,
+    loginModalOpen,
+    closeLoginModal,
+    botId,
+    botUsername,
+    useWidget
+  } = useHypurrConnectInternal();
   const handleTelegramAuth = useCallback2(
     (user) => {
       loginTelegram(user);
@@ -682,7 +1046,7 @@ function LoginModal({ onConnectWallet, walletIcon }) {
     },
     [loginTelegram, closeLoginModal]
   );
-  useEffect2(() => {
+  useEffect3(() => {
     if (!loginModalOpen) return;
     function onMessage(e) {
       if (e.origin !== "https://oauth.telegram.org") return;
@@ -721,7 +1085,7 @@ function LoginModal({ onConnectWallet, walletIcon }) {
   }, [botId]);
   const isMobile = useIsMobile();
   const modalContent = /* @__PURE__ */ jsxs3(Fragment, { children: [
-    /* @__PURE__ */ jsx4(
+    /* @__PURE__ */ jsx5(
       "div",
       {
         style: {
@@ -732,13 +1096,19 @@ function LoginModal({ onConnectWallet, walletIcon }) {
           gap: 8,
           overflow: "hidden"
         },
-        children: /* @__PURE__ */ jsxs3(HoverButton, { onClick: openTelegramOAuth, children: [
-          /* @__PURE__ */ jsx4(TelegramColorIcon, { style: iconSize }),
+        children: useWidget && botUsername ? /* @__PURE__ */ jsx5(
+          TelegramLoginWidget,
+          {
+            botUsername,
+            onAuth: handleTelegramAuth
+          }
+        ) : /* @__PURE__ */ jsxs3(HoverButton, { onClick: openTelegramOAuth, children: [
+          /* @__PURE__ */ jsx5(TelegramColorIcon, { style: iconSize }),
           "Telegram"
         ] })
       }
     ),
-    /* @__PURE__ */ jsx4("div", { style: dividerStyle }),
+    /* @__PURE__ */ jsx5("div", { style: dividerStyle }),
     /* @__PURE__ */ jsxs3(
       HoverButton,
       {
@@ -747,14 +1117,14 @@ function LoginModal({ onConnectWallet, walletIcon }) {
           onConnectWallet();
         },
         children: [
-          walletIcon ?? /* @__PURE__ */ jsx4(MetaMaskColorIcon, { style: iconSize }),
+          walletIcon ?? /* @__PURE__ */ jsx5(MetaMaskColorIcon, { style: iconSize }),
           "Wallet"
         ]
       }
     )
   ] });
-  return /* @__PURE__ */ jsx4(AnimatePresence, { children: loginModalOpen && (isMobile ? /* @__PURE__ */ jsx4(MobileDrawer, { onClose: closeLoginModal, children: modalContent }, "drawer") : /* @__PURE__ */ jsxs3(Fragment, { children: [
-    /* @__PURE__ */ jsx4(
+  return /* @__PURE__ */ jsx5(AnimatePresence, { children: loginModalOpen && (isMobile ? /* @__PURE__ */ jsx5(MobileDrawer, { onClose: closeLoginModal, children: modalContent }, "drawer") : /* @__PURE__ */ jsxs3(Fragment, { children: [
+    /* @__PURE__ */ jsx5(
       motion.div,
       {
         style: backdropStyle,
@@ -766,7 +1136,7 @@ function LoginModal({ onConnectWallet, walletIcon }) {
       },
       "backdrop"
     ),
-    /* @__PURE__ */ jsx4(
+    /* @__PURE__ */ jsx5(
       motion.div,
       {
         style: modalWrapperStyle,
@@ -785,7 +1155,7 @@ function LoginModal({ onConnectWallet, walletIcon }) {
             transition: { duration: 0.2, ease: "easeOut" },
             onClick: (e) => e.stopPropagation(),
             children: [
-              /* @__PURE__ */ jsx4("p", { style: headingStyle, children: "Connect" }),
+              /* @__PURE__ */ jsx5("p", { style: headingStyle, children: "Connect" }),
               modalContent
             ]
           }
@@ -852,7 +1222,7 @@ function MobileDrawer({
     [onClose, controls]
   );
   return /* @__PURE__ */ jsxs3(Fragment, { children: [
-    /* @__PURE__ */ jsx4(
+    /* @__PURE__ */ jsx5(
       motion.div,
       {
         style: backdropStyle,
@@ -877,9 +1247,9 @@ function MobileDrawer({
         dragElastic: { top: 0, bottom: 0.4 },
         onDragEnd: handleDragEnd,
         children: [
-          /* @__PURE__ */ jsx4("div", { style: drawerBgStyle }),
-          /* @__PURE__ */ jsx4("div", { style: grabHandleAreaStyle, children: /* @__PURE__ */ jsx4("div", { style: grabHandleStyle }) }),
-          /* @__PURE__ */ jsx4("p", { style: headingStyle, children: "Connect" }),
+          /* @__PURE__ */ jsx5("div", { style: drawerBgStyle }),
+          /* @__PURE__ */ jsx5("div", { style: grabHandleAreaStyle, children: /* @__PURE__ */ jsx5("div", { style: grabHandleStyle }) }),
+          /* @__PURE__ */ jsx5("p", { style: headingStyle, children: "Connect" }),
           children
         ]
       },
@@ -887,10 +1257,21 @@ function MobileDrawer({
     )
   ] });
 }
+
+// src/types.ts
+function createEoaSigner(signTypedDataAsync, chainId) {
+  const resolve = typeof signTypedDataAsync === "function" ? signTypedDataAsync : (args) => signTypedDataAsync.current(args);
+  return {
+    signTypedData: (params) => resolve(params),
+    chainId
+  };
+}
 export {
   GrpcExchangeTransport,
   HypurrConnectProvider,
   LoginModal,
+  TelegramLoginWidget,
+  createEoaSigner,
   createStaticClient,
   createTelegramClient,
   useHypurrConnect