@hfunlabs/hypurr-connect 0.1.1 → 0.1.2

package/dist/index.js

@@ -1,9 +1,9 @@
 // src/HypurrConnectProvider.tsx
 import {
   ExchangeClient,
-  HttpTransport,
-  InfoClient
+  HttpTransport
 } from "@hfunlabs/hyperliquid";
+import { approveAgent as sdkApproveAgent } from "@hfunlabs/hyperliquid/api/exchange";
 import { PrivateKeySigner } from "@hfunlabs/hyperliquid/signing";
 import {
   createContext,
@@ -11,10 +11,12 @@ import {
   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 +43,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 +187,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 +218,7 @@ function HypurrConnectProvider({
     () => tgLoginData ? toAuthDataMap(tgLoginData) : {},
     [tgLoginData]
   );
+  const [tgUserTick, setTgUserTick] = useState(0);
   useEffect(() => {
     if (!tgLoginData) return;
     let cancelled = false;
@@ -183,9 +227,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 +241,55 @@ 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 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,16 @@ 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 agentReady = authMethod === "telegram" || authMethod === "eoa" && !!agent;
   const exchange = useMemo(() => {
     if (authMethod === "telegram" && user?.address) {
       const transport = new GrpcExchangeTransport({
@@ -246,127 +325,129 @@ function HypurrConnectProvider({
         userAddress: user.address
       });
     }
-    if (authMethod === "eoa" && agent) {
+    if (authMethod === "eoa" && eoaAddress) {
+      if (!agent) {
+        const noAgentTransport = {
+          isTestnet: config.isTestnet ?? false,
+          request() {
+            throw new Error(
+              "[HypurrConnect] No agent key approved. Call approveAgent(signTypedDataAsync) before using the exchange client. This is required for EOA wallets to sign transactions on Hyperliquid."
+            );
+          }
+        };
+        return new ExchangeClient({
+          transport: noAgentTransport,
+          externalSigning: true,
+          userAddress: eoaAddress
+        });
+      }
+      const inner = new HttpTransport({
+        isTestnet: config.isTestnet ?? false
+      });
+      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 wallet = new PrivateKeySigner(agent.privateKey);
       return new ExchangeClient({
-        transport: new HttpTransport({
-          isTestnet: config.isTestnet ?? false
-        }),
+        transport: guardedTransport,
         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 (!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 types = {
-        "HyperliquidTransaction:ApproveAgent": [
-          { name: "hyperliquidChain", type: "string" },
-          { name: "agentAddress", type: "address" },
-          { name: "agentName", type: "string" },
-          { name: "nonce", type: "uint64" }
-        ]
-      };
-      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 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]
-  );
+  }, [
+    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,42 +456,115 @@ function HypurrConnectProvider({
     localStorage.setItem(TELEGRAM_STORAGE_KEY, JSON.stringify(data));
     setEoaAddress(null);
     setAgent(null);
+    setEoaError(null);
   }, []);
-  const loginEoa = useCallback((address) => {
+  const connectEoa = useCallback((address) => {
     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."
+        );
+      }
+      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 wallet = {
+          signTypedData: signTypedDataAsync,
+          getAddresses: async () => [eoaAddress],
+          getChainId: async () => chainId
+        };
+        const transport = new HttpTransport({ isTestnet });
+        await sdkApproveAgent(
+          { transport, wallet },
+          {
+            agentAddress: agentAddress.toLowerCase(),
+            agentName: AGENT_NAME
+          }
+        );
+        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);
     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 ?? "",
       authDataMap,
@@ -420,20 +574,31 @@ 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,
       authDataMap,
@@ -674,7 +839,7 @@ function HoverButton({
   );
 }
 function LoginModal({ onConnectWallet, walletIcon }) {
-  const { loginTelegram, loginModalOpen, closeLoginModal, botId } = useHypurrConnect();
+  const { loginTelegram, loginModalOpen, closeLoginModal, botId } = useHypurrConnectInternal();
   const handleTelegramAuth = useCallback2(
     (user) => {
       loginTelegram(user);