@b3dotfun/sdk 0.0.73-test.3 → 0.0.74-alpha.0

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

@@ -0,0 +1,229 @@
+import { getAuthToken } from "@b3dotfun/sdk/shared/utils/auth-token";
+import { debugB3React } from "@b3dotfun/sdk/shared/utils/debug";
+import { useCallback, useEffect, useState } from "react";
+import { useB3 } from "../components";
+import { notificationsAPI, UserData } from "../utils/notificationsAPI";
+import { useUserQuery } from "./useUserQuery";
+
+const debug = debugB3React("useNotifications");
+
+export interface UseNotificationsReturn {
+  /** User's notification data including channels and settings */
+  userData: UserData | null;
+  /** Whether the data is currently loading */
+  loading: boolean;
+  /** Any error that occurred */
+  error: string | null;
+  /** Whether email channel is connected */
+  isEmailConnected: boolean;
+  /** Whether Telegram channel is connected */
+  isTelegramConnected: boolean;
+  /** Whether user has any channel connected */
+  hasAnyChannelConnected: boolean;
+  /** Connect an email channel */
+  connectEmail: (email: string) => Promise<void>;
+  /** Connect Telegram channel (opens deep link) */
+  connectTelegram: () => Promise<void>;
+  /** Disconnect a channel */
+  disconnectChannel: (channelType: string) => Promise<void>;
+  /** Send a test notification */
+  sendTestNotification: () => Promise<void>;
+  /** Refresh user data */
+  refresh: () => Promise<void>;
+  /** Telegram connection status */
+  telegramStatus: "idle" | "pending" | "connected";
+}
+
+/**
+ * Hook for managing user notification settings and channels
+ *
+ * @example
+ * ```typescript
+ * const {
+ *   userData,
+ *   loading,
+ *   isEmailConnected,
+ *   connectEmail,
+ *   sendTestNotification
+ * } = useNotifications();
+ *
+ * // Connect email
+ * await connectEmail('user@example.com');
+ *
+ * // Send test
+ * await sendTestNotification();
+ * ```
+ */
+export function useNotifications(): UseNotificationsReturn {
+  const { user } = useUserQuery();
+  const { partnerId } = useB3();
+  const [userData, setUserData] = useState<UserData | null>(null);
+  const [loading, setLoading] = useState(true);
+  const [error, setError] = useState<string | null>(null);
+  const [telegramStatus, setTelegramStatus] = useState<"idle" | "pending" | "connected">("idle");
+
+  const userId = (user as any)?.userId;
+  const jwtToken = getAuthToken();
+
+  const loadUserData = useCallback(async () => {
+    if (!userId || !jwtToken) {
+      setLoading(false);
+      return;
+    }
+
+    try {
+      setLoading(true);
+      const data = await notificationsAPI.getUser(userId, jwtToken);
+      setUserData(data);
+      setError(null);
+    } catch (err: any) {
+      debug("Error loading user data:", err);
+      // Try to register the user if they don't exist
+      try {
+        await notificationsAPI.registerUser(jwtToken);
+        const data = await notificationsAPI.getUser(userId, jwtToken);
+        setUserData(data);
+        setError(null);
+      } catch (registerErr: any) {
+        debug("Error registering user:", registerErr);
+        setError("Failed to load notification settings");
+      }
+    } finally {
+      setLoading(false);
+    }
+  }, [userId, jwtToken]);
+
+  useEffect(() => {
+    loadUserData();
+  }, [loadUserData]);
+
+  const createDefaultNotificationSettings = useCallback(async () => {
+    if (!userId || !jwtToken) return;
+
+    try {
+      // Create settings for test notifications only
+      await notificationsAPI.ensureNotificationSettings(userId, partnerId, "general", jwtToken);
+    } catch (err) {
+      debug("Error creating default notification settings:", err);
+    }
+  }, [userId, jwtToken, partnerId]);
+
+  const connectEmail = useCallback(
+    async (email: string) => {
+      if (!userId || !jwtToken) {
+        throw new Error("User not authenticated");
+      }
+
+      try {
+        await notificationsAPI.connectEmail(userId, email, jwtToken);
+        await createDefaultNotificationSettings();
+        await loadUserData();
+      } catch (err: any) {
+        debug("Error connecting email:", err);
+        throw new Error("Failed to connect email");
+      }
+    },
+    [userId, jwtToken, loadUserData, createDefaultNotificationSettings],
+  );
+
+  const connectTelegram = useCallback(async () => {
+    if (!userId || !jwtToken) {
+      throw new Error("User not authenticated");
+    }
+
+    try {
+      const { deepLink } = await notificationsAPI.getTelegramLink(jwtToken);
+      window.open(deepLink, "_blank");
+      setTelegramStatus("pending");
+
+      // Poll for connection using nested timeouts to avoid overlapping requests
+      const startTime = Date.now();
+      const maxDuration = 120000; // 2 minutes
+      let timeoutId: NodeJS.Timeout | null = null;
+
+      const pollStatus = async () => {
+        try {
+          const { connected } = await notificationsAPI.checkTelegramStatus(userId, jwtToken);
+          if (connected) {
+            if (timeoutId) clearTimeout(timeoutId);
+            setTelegramStatus("connected");
+            await createDefaultNotificationSettings();
+            await loadUserData();
+            return;
+          }
+        } catch (err) {
+          debug("Error checking Telegram status:", err);
+        }
+
+        // Check if we've exceeded max duration
+        if (Date.now() - startTime < maxDuration) {
+          // Schedule next check after previous one completes
+          timeoutId = setTimeout(pollStatus, 2000);
+        } else {
+          setTelegramStatus("idle");
+        }
+      };
+
+      // Start polling
+      timeoutId = setTimeout(pollStatus, 2000);
+    } catch (err: any) {
+      debug("Error connecting Telegram:", err);
+      throw new Error("Failed to connect Telegram");
+    }
+  }, [userId, jwtToken, loadUserData, createDefaultNotificationSettings]);
+
+  const disconnectChannel = useCallback(
+    async (channelType: string) => {
+      if (!userId || !jwtToken) {
+        throw new Error("User not authenticated");
+      }
+
+      try {
+        await notificationsAPI.disconnectChannel(userId, channelType, jwtToken);
+        await loadUserData();
+        if (channelType === "telegram") {
+          setTelegramStatus("idle");
+        }
+      } catch (err: any) {
+        debug("Error disconnecting channel:", err);
+        throw new Error(`Failed to disconnect ${channelType}`);
+      }
+    },
+    [userId, jwtToken, loadUserData],
+  );
+
+  const sendTestNotification = useCallback(async () => {
+    if (!userId || !jwtToken) {
+      throw new Error("User not authenticated");
+    }
+
+    try {
+      // The API method now handles ensuring settings exist
+      await notificationsAPI.sendTestNotification(userId, partnerId, jwtToken);
+    } catch (err: any) {
+      debug("Error sending test notification:", err);
+      throw new Error("Failed to send test notification");
+    }
+  }, [userId, jwtToken, partnerId]);
+
+  const emailChannel = userData?.channels?.find(c => c.channel_type === "email");
+  const telegramChannel = userData?.channels?.find(c => c.channel_type === "telegram");
+  const isEmailConnected = emailChannel?.enabled === 1;
+  const isTelegramConnected = telegramChannel?.enabled === 1;
+  const hasAnyChannelConnected = isEmailConnected || isTelegramConnected;
+
+  return {
+    userData,
+    loading,
+    error,
+    isEmailConnected,
+    isTelegramConnected,
+    hasAnyChannelConnected,
+    connectEmail,
+    connectTelegram,
+    disconnectChannel,
+    sendTestNotification,
+    refresh: loadUserData,
+    telegramStatus,
+  };
+}

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

@@ -30,9 +30,9 @@ async function fetchSimBalance(address: string, chainIdsParam: number[]): Promis
   if (!address) throw new Error("Address is required");
 
   const chainIds = chainIdsParam.length === 0 ? "mainnet" : chainIdsParam.join(",");
-  let url = `https://simdune-api.sean-430.workers.dev/?url=https://api.sim.dune.com/v1/evm/balances/${address}?metadata=logo&chain_ids=${chainIds}`;
-  if (process.env.NEXT_PUBLIC_LOCAL_KEY) {
-    url += `&localkey=${process.env.NEXT_PUBLIC_LOCAL_KEY}`;
+  let url = `https://simdune-api.sean-430.workers.dev/?url=https://api.sim.dune.com/v1/evm/balances/${address}?metadata=logo&chain_ids=${chainIds}&exclude_spam_tokens=true`;
+  if (process.env.NEXT_PUBLIC_SIMDUNE_LOCAL_KEY) {
+    url += `&localkey=${process.env.NEXT_PUBLIC_SIMDUNE_LOCAL_KEY}`;
   }
 
   const response = await fetch(url);

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

@@ -17,6 +17,7 @@ export interface TokenBalanceResult {
   rawBalance: bigint | null;
   formattedBalance: string;
   isLoading: boolean;
+  refetch: () => void;
 }
 
 export function useTokenBalanceDirect({ token, address }: UseTokenBalanceProps): TokenBalanceResult {
@@ -80,5 +81,6 @@ export function useTokenBalanceDirect({ token, address }: UseTokenBalanceProps):
     rawBalance: tokenBalance?.raw || BigInt(0),
     formattedBalance: tokenBalance?.formatted || "0",
     isLoading: isActuallyLoading,
+    refetch,
   };
 }

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

@@ -1,10 +1,11 @@
 import { getChainName, getNativeToken } from "@b3dotfun/sdk/anyspend";
 import app from "@b3dotfun/sdk/global-account/app";
+import { toast } from "@b3dotfun/sdk/global-account/react";
 import { getThirdwebChain, supportedChains } from "@b3dotfun/sdk/shared/constants/chains/supported";
 import { client } from "@b3dotfun/sdk/shared/utils/thirdweb";
 import invariant from "invariant";
 import { useCallback, useState } from "react";
-import { toast } from "sonner";
+
 import { prepareTransaction, sendTransaction as twSendTransaction } from "thirdweb";
 import { isAddress } from "viem";
 import { useSwitchChain } from "wagmi";
@@ -108,7 +109,7 @@ export function useUnifiedChainSwitchAndExecute() {
       } catch (e: any) {
         if (e?.code === -32603 || e?.message?.includes("f is not a function")) {
           // This is a workaround for a bug in the wallet provider.
-          toast(`Switched to ${getChainName(targetChainId)}. Executing…`);
+          toast.success(`Switched to ${getChainName(targetChainId)}. Executing…`);
           return await handleEOASwitchChainAndSendTransaction(targetChainId, params);
         } else {
           console.error(e);

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

@@ -1,5 +1,6 @@
 export { useAuthStore } from "./useAuthStore";
 export { useModalStore } from "./useModalStore";
+export { useRecentAddressesStore } from "./useRecentAddressesStore";
 
 export type {
   AnySpendBuySpinProps,

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

@@ -82,9 +82,9 @@ export interface ManageAccountModalProps extends BaseModalProps {
   /** Partner ID */
   partnerId: string;
   /** Active Tab */
-  activeTab?: "overview" | "tokens" | "nfts" | "apps" | "settings";
+  activeTab?: "home" | "tokens" | "nfts" | "apps" | "settings" | "swap";
   /** Function to set the active tab */
-  setActiveTab?: (tab: "overview" | "tokens" | "nfts" | "apps" | "settings") => void;
+  setActiveTab?: (tab: "home" | "tokens" | "nfts" | "apps" | "settings" | "swap") => void;
   /** Whether to show the referral information */
   showReferralInfo?: boolean;
   /** Whether to show the swap button */
@@ -370,6 +370,16 @@ export interface LinkAccountModalProps extends BaseModalProps {
   chain: Chain;
 }
 
+export interface LinkNewAccountModalProps extends BaseModalProps {
+  type: "linkNewAccount";
+  showBackButton?: boolean;
+  onSuccess?: () => void;
+  onError?: (error: Error) => void;
+  onClose?: () => void;
+  partnerId: string;
+  chain: Chain;
+}
+
 export interface AnySpendDepositHypeProps extends BaseModalProps {
   /** Modal type identifier */
   type: "anySpendDepositHype";
@@ -385,6 +395,8 @@ export interface AnySpendDepositHypeProps extends BaseModalProps {
   mainFooter?: React.ReactNode;
   /** Callback function called when the deposit is successful */
   onSuccess?: (amount?: string) => void;
+  /** Callback function trigger open custom modal */
+  onOpenCustomModal?: () => void;
   /** Custom USD input values for quick amount buttons in fiat onramp */
   customUsdInputValues?: string[];
   /** prefer eoa wallet */
@@ -398,10 +410,42 @@ export interface AvatarEditorModalProps extends BaseModalProps {
   onSuccess?: () => void;
 }
 
-export interface ProfileEditorModalProps extends BaseModalProps {
+/**
+ * Props for the Deposit modal
+ * Allows users to deposit tokens into their global account
+ */
+export interface DepositModalProps extends BaseModalProps {
   /** Modal type identifier */
-  type: "profileEditor";
-  /** Callback function called when profile is successfully updated */
+  type: "deposit";
+  /** Callback function called when deposit is successful */
+  onSuccess?: () => void;
+}
+
+/**
+ * Props for the Send modal
+ * Allows users to send tokens from their global account to another address
+ */
+export interface SendModalProps extends BaseModalProps {
+  /** Modal type identifier */
+  type: "send";
+  /** Pre-filled recipient address (optional) */
+  recipientAddress?: string;
+  /** Callback function called when send is successful */
+  onSuccess?: (txHash?: string) => void;
+}
+
+/**
+ * Props for the Notifications modal
+ * Allows users to manage notification settings and channels
+ */
+export interface NotificationsModalProps extends BaseModalProps {
+  /** Modal type identifier */
+  type: "notifications";
+  /** Partner ID */
+  partnerId: string;
+  /** Blockchain chain information */
+  chain: Chain;
+  /** Callback function called when settings are successfully saved */
   onSuccess?: () => void;
 }
 
@@ -454,9 +498,12 @@ export type ModalContentType =
   | AnySpendSignatureMintProps
   | AnySpendBondKitProps
   | LinkAccountModalProps
+  | LinkNewAccountModalProps
   | AnySpendDepositHypeProps
   | AvatarEditorModalProps
-  | ProfileEditorModalProps
+  | DepositModalProps
+  | SendModalProps
+  | NotificationsModalProps
   | AnySpendCollectorClubPurchaseProps;
 // Add other modal types here like: | OtherModalProps | AnotherModalProps
 

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

@@ -0,0 +1,54 @@
+import { create } from "zustand";
+import { persist } from "zustand/middleware";
+
+interface RecentAddress {
+  address: string;
+  timestamp: number;
+}
+
+interface RecentAddressesStore {
+  recentAddresses: RecentAddress[];
+  addRecentAddress: (address: string) => void;
+  clearRecentAddresses: () => void;
+}
+
+/**
+ * Store for managing recently used addresses in the Send flow
+ * Persists to localStorage and keeps the last 6 unique addresses
+ */
+export const useRecentAddressesStore = create<RecentAddressesStore>()(
+  persist(
+    set => ({
+      recentAddresses: [],
+
+      /**
+       * Add a new address to the recent addresses list
+       * Deduplicates and maintains a maximum of 6 addresses
+       */
+      addRecentAddress: (address: string) => {
+        set(state => {
+          // Remove any existing entry with the same address
+          const filtered = state.recentAddresses.filter(item => item.address.toLowerCase() !== address.toLowerCase());
+
+          // Add the new address at the beginning
+          const updated = [{ address, timestamp: Date.now() }, ...filtered];
+
+          // Keep only the last 6 addresses
+          return {
+            recentAddresses: updated.slice(0, 6),
+          };
+        });
+      },
+
+      /**
+       * Clear all recent addresses
+       */
+      clearRecentAddresses: () => {
+        set({ recentAddresses: [] });
+      },
+    }),
+    {
+      name: "b3-recent-addresses-storage",
+    },
+  ),
+);

package/src/global-account/react/utils/index.ts

@@ -0,0 +1,4 @@
+export * from "./notificationsAPI";
+export * from "./profileDisplay";
+export * from "./toast";
+export * from "./updateAvatar";