@b3dotfun/sdk 0.0.47 → 0.0.48-alpha.1

package/src/global-account/react/hooks/useAuthentication.ts

@@ -1,124 +1,185 @@
 import app from "@b3dotfun/sdk/global-account/app";
 import { authenticateWithB3JWT } from "@b3dotfun/sdk/global-account/bsmnt";
-import { useAuthStore, useB3 } from "@b3dotfun/sdk/global-account/react";
+import { useAuthStore, useSiwe } from "@b3dotfun/sdk/global-account/react";
 import { ecosystemWalletId } from "@b3dotfun/sdk/shared/constants";
-import { b3MainnetThirdWeb } from "@b3dotfun/sdk/shared/constants/chains/supported";
 import { debugB3React } from "@b3dotfun/sdk/shared/utils/debug";
 import { client } from "@b3dotfun/sdk/shared/utils/thirdweb";
-import { useEffect, useRef } from "react";
-import { useActiveWallet, useAutoConnect, useConnectedWallets, useDisconnect } from "thirdweb/react";
-import { ecosystemWallet } from "thirdweb/wallets";
+import { ConnectionOptions } from "@thirdweb-dev/wagmi-adapter";
+import { getConnectors } from "@wagmi/core";
+import { useCallback, useEffect, useRef } from "react";
+import {
+  useActiveWallet,
+  useAutoConnect,
+  useConnectedWallets,
+  useDisconnect,
+  useSetActiveWallet,
+} from "thirdweb/react";
+import { ecosystemWallet, Wallet } from "thirdweb/wallets";
 import { preAuthenticate } from "thirdweb/wallets/in-app";
-import { useConnect } from "./useConnect";
-import { useSiwe } from "./useSiwe";
+import { useAccount, useConnect, useSwitchAccount } from "wagmi";
+import { useUserQuery } from "./useUserQuery";
+import { useWagmiConfig } from "./useWagmiConfig";
 
 const debug = debugB3React("useAuthentication");
 
-export function useAuthentication(partnerId: string, loginWithSiwe?: boolean) {
+export function useAuthentication(partnerId: string) {
   const { disconnect } = useDisconnect();
   const wallets = useConnectedWallets();
   const activeWallet = useActiveWallet();
-  const { authenticate } = useSiwe();
-  const { setUser } = useB3();
   const isAuthenticated = useAuthStore(state => state.isAuthenticated);
   const setIsAuthenticated = useAuthStore(state => state.setIsAuthenticated);
-  const setIsConnecting = useAuthStore(state => state.setIsConnecting);
   const setIsConnected = useAuthStore(state => state.setIsConnected);
   const isConnecting = useAuthStore(state => state.isConnecting);
   const isConnected = useAuthStore(state => state.isConnected);
-  const useAutoConnectLoadingPrevious = useRef(false);
-  const setIsAuthenticating = useAuthStore(state => state.setIsAuthenticating);
   const isAuthenticating = useAuthStore(state => state.isAuthenticating);
-  const hasStartedConnecting = useAuthStore(state => state.hasStartedConnecting);
+  const setIsAuthenticating = useAuthStore(state => state.setIsAuthenticating);
   const setHasStartedConnecting = useAuthStore(state => state.setHasStartedConnecting);
-  const { connect } = useConnect(partnerId, b3MainnetThirdWeb);
+  const setActiveWallet = useSetActiveWallet();
+  const hasStartedConnecting = useAuthStore(state => state.hasStartedConnecting);
+  const { authenticate } = useSiwe();
+  const { user, setUser } = useUserQuery();
+  const useAutoConnectLoadingPrevious = useRef(false);
+  const wagmiConfig = useWagmiConfig(partnerId);
+  const { connect } = useConnect();
+  const activeWagmiAccount = useAccount();
+  const { switchAccount } = useSwitchAccount();
+  debug("@@activeWagmiAccount", activeWagmiAccount);
 
   const wallet = ecosystemWallet(ecosystemWalletId, {
     partnerId: partnerId,
   });
 
-  const { isLoading: useAutoConnectLoading } = useAutoConnect({
-    client,
-    wallets: [wallet],
-    onConnect: async wallet => {
-      setHasStartedConnecting(true);
-
-      try {
-        setIsConnected(true);
-        if (!loginWithSiwe) {
-          debug("Skipping SIWE login", { loginWithSiwe });
-          setIsAuthenticated(true);
-
-          setIsAuthenticating(false);
+  const syncWagmi = useCallback(async () => {
+    function syncWagmiFunc() {
+      const connectors = getConnectors(wagmiConfig);
+      debug("@@syncWagmi", {
+        connectors,
+        wallets,
+      });
+
+      // For each that matchs a TW wallet on wallets, connect to the wagmi connector
+      // or, since ecosystem wallets is separate, connect those via in-app-wallet from wagmi
+      connectors.forEach(async connector => {
+        const twWallet = wallets.find(wallet => wallet.id === connector.id || connector.id === "in-app-wallet");
+
+        // If no TW wallet, do not prompt the user to connect
+        if (!twWallet) {
           return;
         }
-        debug("setIsAuthenticating:true:4");
-        const account = await wallet.getAccount();
-        if (!account) {
-          throw new Error("No account found during auto-connect");
+
+        // Metamask will prompt to connect, we can just switch accounts here.
+        if (connector.id === "io.metamask") {
+          return switchAccount({ connector });
         }
 
-        // Try to re-authenticate first
-        try {
-          const userAuth = await app.reAuthenticate();
-          setUser(userAuth.user);
-          setIsAuthenticated(true);
-          setIsAuthenticating(false);
-          debug("Re-authenticated successfully", { userAuth });
-
-          // Authenticate on BSMNT with B3 JWT
-          const b3Jwt = await authenticateWithB3JWT(userAuth.accessToken);
-          console.log("@@b3Jwt", b3Jwt);
-        } catch (error) {
-          // If re-authentication fails, try fresh authentication
-          debug("Re-authentication failed, attempting fresh authentication");
-          const userAuth = await authenticate(account, partnerId);
-          setUser(userAuth.user);
-          setIsAuthenticated(true);
-          setIsAuthenticating(false);
-          debug("Fresh authentication successful", { userAuth });
-
-          // Authenticate on BSMNT with B3 JWT
-          const b3Jwt = await authenticateWithB3JWT(userAuth.accessToken);
-          console.log("@@b3Jwt", b3Jwt);
+        if (
+          // If it's not an in-app wallet or it is the ecosystem wallet, connect
+          connector.id !== "in-app-wallet" ||
+          (connector.id === "in-app-wallet" && twWallet.id === ecosystemWalletId)
+        ) {
+          try {
+            const options = {
+              wallet: twWallet, // the connected wallet
+            } satisfies ConnectionOptions;
+            debug("@@syncWagmi:connecting", { twWallet, connector });
+            connect({
+              connector,
+              ...options,
+            });
+          } catch (error) {
+            console.error("@@syncWagmi:error", error);
+          }
+        } else {
+          debug("@@syncWagmi:not-connecting", connector);
         }
+      });
+    }
+    syncWagmiFunc();
+    // wagmi config shouldn't change
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, [partnerId, wallets]);
+
+  useEffect(() => {
+    syncWagmi();
+  }, [wallets, syncWagmi]);
+
+  const authenticateUser = useCallback(
+    async (wallet?: Wallet) => {
+      setHasStartedConnecting(true);
+
+      const account = wallet ? wallet.getAccount() : activeWallet?.getAccount();
+      if (!account) {
+        throw new Error("No account found during auto-connect");
+      }
+      if (!account) {
+        throw new Error("No account found during auto-connect");
+      }
+
+      // Try to re-authenticate first
+      try {
+        const userAuth = await app.reAuthenticate();
+        setUser(userAuth.user);
+        setIsAuthenticated(true);
+        setIsAuthenticating(false);
+        debug("Re-authenticated successfully", { userAuth });
+
+        // Authenticate on BSMNT with B3 JWT
+        const b3Jwt = await authenticateWithB3JWT(userAuth.accessToken);
+        debug("@@b3Jwt", b3Jwt);
       } catch (error) {
-        debug("Auto-connect authentication failed", { error });
-        setIsAuthenticated(false);
-        debug("setIsAuthenticating:false:4");
-        setUser();
+        // If re-authentication fails, try fresh authentication
+        debug("Re-authentication failed, attempting fresh authentication");
+        const userAuth = await authenticate(account, partnerId);
+        setUser(userAuth.user);
+        setIsAuthenticated(true);
+        setIsAuthenticating(false);
+        debug("Fresh authentication successful", { userAuth });
+
+        // Authenticate on BSMNT with B3 JWT
+        const b3Jwt = await authenticateWithB3JWT(userAuth.accessToken);
+        debug("@@b3Jwt", b3Jwt);
       }
-      setIsAuthenticating(false);
     },
-  });
+    [activeWallet, partnerId, authenticate, setIsAuthenticated, setIsAuthenticating, setUser, setHasStartedConnecting],
+  );
 
-  /**
-   * useAutoConnectLoading starts as false
-   */
-  useEffect(() => {
-    if (!useAutoConnectLoading && useAutoConnectLoadingPrevious.current && !hasStartedConnecting) {
-      setIsAuthenticating(false);
-    }
-    useAutoConnectLoadingPrevious.current = useAutoConnectLoading;
-  }, [useAutoConnectLoading, hasStartedConnecting, setIsAuthenticating]);
+  const onConnect = useCallback(
+    async (wallet: Wallet) => {
+      debug("@@useAuthentication:onConnect", { wallet });
 
-  // Ensure isAuthenticating stays true until we're fully ready
-  useEffect(() => {
-    if (useAutoConnectLoading) {
-      setIsConnecting(true);
-    } else if (!isAuthenticated) {
-      // Only set isAuthenticating to false if we're not authenticated
-      // This prevents the flicker state where both isAuthenticating and isAuthenticated are false
-      const timeout = setTimeout(() => {
-        debug("setIsAuthenticating:false:5a");
-        setIsConnecting(false);
-      }, 100); // Add a small delay to prevent quick flickers
-      return () => clearTimeout(timeout);
-    } else {
-      debug("setIsAuthenticating:false:5b");
-      setIsConnecting(false);
-    }
-  }, [useAutoConnectLoading, isAuthenticated, setIsConnecting, setIsConnected]);
+      try {
+        setHasStartedConnecting(true);
+        setIsConnected(true);
+        setIsAuthenticating(true);
+        await setActiveWallet(wallet);
+        await authenticateUser(wallet);
+      } catch (error) {
+        debug("@@useAuthentication:onConnect:failed", { error });
+        setIsAuthenticated(false);
+        setUser(undefined);
+      } finally {
+        setIsAuthenticating(false);
+      }
+
+      debug({
+        isAuthenticated,
+        isAuthenticating,
+        isConnected,
+      });
+    },
+    [
+      authenticateUser,
+      isAuthenticated,
+      isAuthenticating,
+      isConnected,
+      setActiveWallet,
+      setHasStartedConnecting,
+      setIsAuthenticated,
+      setIsAuthenticating,
+      setIsConnected,
+      setUser,
+    ],
+  );
 
   const logout = async (callback?: () => void) => {
     if (activeWallet) {
@@ -150,7 +211,23 @@ export function useAuthentication(partnerId: string, loginWithSiwe?: boolean) {
     callback?.();
   };
 
-  const isReady = isAuthenticated && !useAutoConnectLoading && !isAuthenticating;
+  const { isLoading: useAutoConnectLoading } = useAutoConnect({
+    client,
+    wallets: [wallet],
+    onConnect: onConnect,
+  });
+
+  /**
+   * useAutoConnectLoading starts as false
+   */
+  useEffect(() => {
+    if (!useAutoConnectLoading && useAutoConnectLoadingPrevious.current && !hasStartedConnecting) {
+      setIsAuthenticating(false);
+    }
+    useAutoConnectLoadingPrevious.current = useAutoConnectLoading;
+  }, [useAutoConnectLoading, hasStartedConnecting, setIsAuthenticating]);
+
+  const isReady = isAuthenticated && !isAuthenticating;
 
   return {
     logout,
@@ -160,7 +237,11 @@ export function useAuthentication(partnerId: string, loginWithSiwe?: boolean) {
     isConnected,
     wallet,
     preAuthenticate,
-    connect,
+    connect: onConnect,
     isAuthenticating,
+    onConnect,
+    user,
+    refetchUser: authenticateUser,
+    setUser,
   };
 }

package/src/global-account/react/hooks/useHandleConnectWithPrivy.tsx

@@ -1,4 +1,4 @@
-import { useConnect } from "@b3dotfun/sdk/global-account/react";
+import { useB3, useConnect } from "@b3dotfun/sdk/global-account/react";
 import { debugB3React } from "@b3dotfun/sdk/shared/utils/debug";
 import { useIdentityToken, usePrivy } from "@privy-io/react-auth";
 import { useCallback, useRef, useState } from "react";
@@ -10,7 +10,8 @@ const debug = debugB3React("@@b3:useHandleConnectWithPrivy");
  * This essentially wraps our useConnect hook to handle the Privy auth flow.
  * Currently, this is for the basement-privy strategy
  */
-export function useHandleConnectWithPrivy(partnerId: string, chain?: Chain, onSuccess?: (account: Account) => void) {
+export function useHandleConnectWithPrivy(chain?: Chain, onSuccess?: (account: Account) => void) {
+  const { partnerId } = useB3();
   if (!chain) {
     throw new Error("Chain is required");
   }

package/src/global-account/react/hooks/useUserQuery.ts

@@ -0,0 +1,95 @@
+import { Users } from "@b3dotfun/b3-api";
+import { debugB3React } from "@b3dotfun/sdk/shared/utils/debug";
+import { useMutation, useQuery, useQueryClient } from "@tanstack/react-query";
+
+const debug = debugB3React("useUserQuery");
+
+const USER_QUERY_KEY = ["b3-user"];
+
+/**
+ * Retrieves the user from localStorage
+ */
+function getUserFromStorage(): Users | null {
+  if (typeof window === "undefined") {
+    return null;
+  }
+
+  try {
+    const storedUser = localStorage.getItem("b3-user");
+    return storedUser ? JSON.parse(storedUser) : null;
+  } catch (error) {
+    console.warn("Failed to restore user from localStorage:", error);
+    return null;
+  }
+}
+
+/**
+ * Saves user to localStorage
+ */
+function saveUserToStorage(user: Users | null) {
+  if (typeof window === "undefined") {
+    return;
+  }
+
+  if (user) {
+    localStorage.setItem("b3-user", JSON.stringify(user));
+  } else {
+    localStorage.removeItem("b3-user");
+  }
+}
+
+/**
+ * NOTE: THIS IS ONLY MEANT FOR INTERNAL USE, from useOnConnect
+ *
+ * Custom hook to manage user state with react-query
+ * This allows for invalidation and refetching of user data
+ */
+export function useUserQuery() {
+  const queryClient = useQueryClient();
+
+  // Query to get user data (primarily from cache/localStorage)
+  const { data: user } = useQuery<Users | null>({
+    queryKey: USER_QUERY_KEY,
+    queryFn: getUserFromStorage,
+    staleTime: Infinity, // User data doesn't go stale automatically
+    gcTime: Infinity, // Keep in cache indefinitely
+    initialData: getUserFromStorage,
+  });
+
+  // Mutation to update user
+  const setUserMutation = useMutation({
+    mutationFn: async (newUser: Users | undefined) => {
+      const userToSave = newUser ?? null;
+      saveUserToStorage(userToSave);
+      return userToSave;
+    },
+    onSuccess: data => {
+      queryClient.setQueryData(USER_QUERY_KEY, data);
+      debug("User updated", data);
+    },
+  });
+
+  // Helper function to set user (maintains backward compatibility)
+  const setUser = (newUser?: Users) => {
+    setUserMutation.mutate(newUser);
+  };
+
+  // Helper function to invalidate and refetch user
+  const refetchUser = async () => {
+    await queryClient.invalidateQueries({ queryKey: USER_QUERY_KEY });
+    return queryClient.refetchQueries({ queryKey: USER_QUERY_KEY });
+  };
+
+  // Helper function to clear user
+  const clearUser = () => {
+    setUser(undefined);
+  };
+
+  return {
+    user: user ?? undefined,
+    setUser,
+    refetchUser,
+    clearUser,
+    queryKey: USER_QUERY_KEY,
+  };
+}

package/src/global-account/react/hooks/useWagmiConfig.tsx

@@ -0,0 +1,44 @@
+import { ecosystemWalletId } from "@b3dotfun/sdk/shared/constants";
+import { supportedChains } from "@b3dotfun/sdk/shared/constants/chains/supported";
+import { client } from "@b3dotfun/sdk/shared/utils/thirdweb";
+import { inAppWalletConnector } from "@thirdweb-dev/wagmi-adapter";
+import { useMemo } from "react";
+import { http } from "viem";
+import { createConfig } from "wagmi";
+
+export function useWagmiConfig(partnerId: string, rpcUrls?: Record<number, string>) {
+  // Stringify rpcUrls for stable comparison to prevent wagmiConfig recreation
+  // when parent component passes new object references with same content
+  const rpcUrlsString = useMemo(() => (rpcUrls ? JSON.stringify(rpcUrls) : undefined), [rpcUrls]);
+
+  const ecocystemConfig = useMemo(() => {
+    return {
+      ecosystemId: ecosystemWalletId,
+      partnerId: partnerId,
+      client,
+    };
+  }, [partnerId]);
+
+  /**
+   * Creates wagmi config with optional custom RPC URLs
+   * @param rpcUrls - Optional mapping of chain IDs to RPC URLs
+   */
+  const wagmiConfig = useMemo(() => {
+    const parsedRpcUrls = rpcUrlsString ? JSON.parse(rpcUrlsString) : undefined;
+
+    return createConfig({
+      chains: [supportedChains[0], ...supportedChains.slice(1)],
+      transports: Object.fromEntries(supportedChains.map(chain => [chain.id, http(parsedRpcUrls?.[chain.id])])),
+      connectors: [
+        inAppWalletConnector({
+          ...ecocystemConfig,
+          client,
+        }),
+        // injected(),
+        // coinbaseWallet({ appName: "HypeDuel" }),
+      ],
+    });
+  }, [rpcUrlsString, ecocystemConfig]);
+
+  return wagmiConfig;
+}

package/src/global-account/react/stores/useModalStore.ts

@@ -35,8 +35,6 @@ export interface SignInWithB3ModalProps extends BaseModalProps {
   sessionKeyAddress?: Address;
   /** Unique identifier for the partner application */
   partnerId: string;
-  /** Whether to authenticate with Sign In With Ethereum */
-  loginWithSiwe?: boolean;
   /** Whether to close the modal after successful login */
   closeAfterLogin?: boolean;
   /** Source of the sign-in request */

package/src/notifications/index.ts

@@ -0,0 +1,9 @@
+// Export types
+export * from "./types";
+
+// Export services
+export * from "./services";
+
+// Re-export auth token getter from shared for convenience
+// Note: Auth token is managed by B3 Global Account authentication
+export { getAuthToken } from "../shared/utils/auth-token";

package/src/notifications/react/hooks/index.ts

@@ -0,0 +1 @@
+export * from "./useNotifications";

package/src/notifications/react/hooks/useNotifications.ts

@@ -0,0 +1,153 @@
+import { useEffect, useRef, useState } from "react";
+import { notificationsAPI } from "../../services/api";
+import type { UserData } from "../../types";
+
+/**
+ * React hook for managing B3 notifications
+ * Automatically uses the authenticated user's ID from JWT
+ *
+ * @example
+ * ```tsx
+ * import { useNotifications } from '@b3dotfun/sdk/notifications/react';
+ *
+ * function NotificationSettings() {
+ *   const { user, loading, connectEmail, connectTelegram, isEmailConnected } = useNotifications();
+ *
+ *   if (loading) return <div>Loading...</div>;
+ *
+ *   return (
+ *     <div>
+ *       {!isEmailConnected && (
+ *         <button onClick={() => connectEmail('user@example.com')}>
+ *           Connect Email
+ *         </button>
+ *       )}
+ *       <button onClick={connectTelegram}>Connect Telegram</button>
+ *     </div>
+ *   );
+ * }
+ * ```
+ */
+export function useNotifications() {
+  const [user, setUser] = useState<UserData | null>(null);
+  const [loading, setLoading] = useState(true);
+  const [error, setError] = useState<Error | null>(null);
+
+  // Refs to track polling timers for cleanup
+  const telegramPollIntervalRef = useRef<NodeJS.Timeout | null>(null);
+  const telegramPollTimeoutRef = useRef<NodeJS.Timeout | null>(null);
+
+  // Cleanup function for Telegram polling
+  const cleanupTelegramPolling = () => {
+    if (telegramPollIntervalRef.current) {
+      clearInterval(telegramPollIntervalRef.current);
+      telegramPollIntervalRef.current = null;
+    }
+    if (telegramPollTimeoutRef.current) {
+      clearTimeout(telegramPollTimeoutRef.current);
+      telegramPollTimeoutRef.current = null;
+    }
+  };
+
+  // Load user data on mount
+  useEffect(() => {
+    loadUser();
+  }, []);
+
+  // Cleanup polling on unmount
+  useEffect(() => {
+    return () => {
+      cleanupTelegramPolling();
+    };
+  }, []);
+
+  const loadUser = async () => {
+    try {
+      setLoading(true);
+      setError(null);
+      const userData = await notificationsAPI.getUser();
+      setUser(userData);
+    } catch (err) {
+      setError(err instanceof Error ? err : new Error("Failed to load user"));
+      console.error("Failed to load user:", err);
+    } finally {
+      setLoading(false);
+    }
+  };
+
+  const connectEmail = async (email: string) => {
+    try {
+      await notificationsAPI.connectEmail(email);
+      await loadUser(); // Refresh user data
+    } catch (err) {
+      console.error("Failed to connect email:", err);
+      throw err;
+    }
+  };
+
+  const connectTelegram = async () => {
+    try {
+      // Clear any existing polling before starting new one
+      cleanupTelegramPolling();
+
+      const { deepLink } = await notificationsAPI.getTelegramLink();
+      window.open(deepLink, "_blank");
+
+      // Poll for connection status
+      telegramPollIntervalRef.current = setInterval(async () => {
+        try {
+          const { connected } = await notificationsAPI.checkTelegramStatus();
+          if (connected) {
+            cleanupTelegramPolling();
+            await loadUser(); // Refresh user data
+          }
+        } catch (err) {
+          console.error("Failed to check Telegram status:", err);
+        }
+      }, 2000);
+
+      // Stop polling after 2 minutes
+      telegramPollTimeoutRef.current = setTimeout(() => {
+        cleanupTelegramPolling();
+      }, 120000);
+    } catch (err) {
+      console.error("Failed to connect Telegram:", err);
+      throw err;
+    }
+  };
+
+  const updateChannel = async (channelId: string, updates: { enabled?: boolean }) => {
+    try {
+      await notificationsAPI.updateChannel(channelId, updates);
+      await loadUser(); // Refresh user data
+    } catch (err) {
+      console.error("Failed to update channel:", err);
+      throw err;
+    }
+  };
+
+  const deleteChannel = async (channelId: string) => {
+    try {
+      await notificationsAPI.deleteChannel(channelId);
+      await loadUser(); // Refresh user data
+    } catch (err) {
+      console.error("Failed to delete channel:", err);
+      throw err;
+    }
+  };
+
+  return {
+    user,
+    loading,
+    error,
+    refresh: loadUser,
+    connectEmail,
+    connectTelegram,
+    updateChannel,
+    deleteChannel,
+    // Convenience helpers
+    isEmailConnected: user?.channels?.find(c => c.channel_type === "email")?.enabled === 1,
+    isTelegramConnected: user?.channels?.find(c => c.channel_type === "telegram")?.enabled === 1,
+    isDiscordConnected: user?.channels?.find(c => c.channel_type === "discord")?.enabled === 1,
+  };
+}

package/src/notifications/react/index.ts

@@ -0,0 +1 @@
+export * from "./hooks";