@b3dotfun/sdk 0.0.47 → 0.0.48

package/dist/cjs/global-account/react/hooks/useUserQuery.d.ts

@@ -0,0 +1,58 @@
+import { Users } from "@b3dotfun/b3-api";
+/**
+ * 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 declare function useUserQuery(): {
+    user: {
+        email?: string | undefined;
+        username?: string | undefined;
+        telNumber?: string | undefined;
+        ens?: string | undefined;
+        avatar?: string | undefined;
+        preferences?: {} | undefined;
+        referredBy?: string | {} | undefined;
+        sourceApp?: string | undefined;
+        referralCode?: string | undefined;
+        userGroups?: number[] | undefined;
+        isMigratedFromBSMNT?: boolean | undefined;
+        privyLinkedAccounts?: {
+            name?: string | undefined;
+            address?: string | undefined;
+            email?: string | undefined;
+            chain_type?: string | undefined;
+            lv?: number | undefined;
+            wallet_client_type?: string | undefined;
+            smart_wallet_type?: string | undefined;
+            subject?: string | undefined;
+            type: string;
+        }[] | undefined;
+        twProfiles?: {
+            type: string;
+            details: {
+                id?: string | undefined;
+                name?: string | undefined;
+                address?: string | undefined;
+                email?: string | undefined;
+                phone?: string | undefined;
+                username?: string | undefined;
+                fid?: string | undefined;
+            };
+        }[] | undefined;
+        _id: string | {};
+        userId: string;
+        smartAccountAddress: string;
+        createdAt: number;
+        updatedAt: number;
+        partnerIds: {
+            privyId?: string | undefined;
+            thirdwebId?: string | undefined;
+        };
+    } | undefined;
+    setUser: (newUser?: Users) => void;
+    refetchUser: () => Promise<void>;
+    clearUser: () => void;
+    queryKey: string[];
+};

package/dist/cjs/global-account/react/hooks/useUserQuery.js

@@ -0,0 +1,86 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useUserQuery = useUserQuery;
+const debug_1 = require("../../../shared/utils/debug");
+const react_query_1 = require("@tanstack/react-query");
+const debug = (0, debug_1.debugB3React)("useUserQuery");
+const USER_QUERY_KEY = ["b3-user"];
+/**
+ * Retrieves the user from localStorage
+ */
+function getUserFromStorage() {
+    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) {
+    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
+ */
+function useUserQuery() {
+    const queryClient = (0, react_query_1.useQueryClient)();
+    // Query to get user data (primarily from cache/localStorage)
+    const { data: user } = (0, react_query_1.useQuery)({
+        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 = (0, react_query_1.useMutation)({
+        mutationFn: async (newUser) => {
+            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) => {
+        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/dist/cjs/global-account/react/hooks/useWagmiConfig.d.ts

@@ -0,0 +1,13 @@
+export declare function useWagmiConfig(partnerId: string, rpcUrls?: Record<number, string>): import("wagmi").Config<readonly [import("viem").Chain, ...import("viem").Chain[]], {
+    [k: string]: import("viem").HttpTransport<undefined, false>;
+}, readonly [import("wagmi").CreateConnectorFn<import("thirdweb/dist/types/adapters/eip1193").EIP1193Provider | undefined, {
+    connect<withCapabilities extends boolean = false>(parameters?: import("@thirdweb-dev/wagmi-adapter").ConnectionOptions<withCapabilities> | undefined): Promise<{
+        accounts: withCapabilities extends true ? readonly {
+            address: `0x${string}`;
+            capabilities: Record<string, unknown>;
+        }[] : readonly `0x${string}`[];
+        chainId: number;
+    }>;
+}, {
+    "thirdweb:lastChainId": number;
+}>]>;

package/dist/cjs/global-account/react/hooks/useWagmiConfig.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useWagmiConfig = useWagmiConfig;
+const constants_1 = require("../../../shared/constants");
+const supported_1 = require("../../../shared/constants/chains/supported");
+const thirdweb_1 = require("../../../shared/utils/thirdweb");
+const wagmi_adapter_1 = require("@thirdweb-dev/wagmi-adapter");
+const react_1 = require("react");
+const viem_1 = require("viem");
+const wagmi_1 = require("wagmi");
+function useWagmiConfig(partnerId, rpcUrls) {
+    // Stringify rpcUrls for stable comparison to prevent wagmiConfig recreation
+    // when parent component passes new object references with same content
+    const rpcUrlsString = (0, react_1.useMemo)(() => (rpcUrls ? JSON.stringify(rpcUrls) : undefined), [rpcUrls]);
+    const ecocystemConfig = (0, react_1.useMemo)(() => {
+        return {
+            ecosystemId: constants_1.ecosystemWalletId,
+            partnerId: partnerId,
+            client: thirdweb_1.client,
+        };
+    }, [partnerId]);
+    /**
+     * Creates wagmi config with optional custom RPC URLs
+     * @param rpcUrls - Optional mapping of chain IDs to RPC URLs
+     */
+    const wagmiConfig = (0, react_1.useMemo)(() => {
+        const parsedRpcUrls = rpcUrlsString ? JSON.parse(rpcUrlsString) : undefined;
+        return (0, wagmi_1.createConfig)({
+            chains: [supported_1.supportedChains[0], ...supported_1.supportedChains.slice(1)],
+            transports: Object.fromEntries(supported_1.supportedChains.map(chain => [chain.id, (0, viem_1.http)(parsedRpcUrls?.[chain.id])])),
+            connectors: [
+                (0, wagmi_adapter_1.inAppWalletConnector)({
+                    ...ecocystemConfig,
+                    client: thirdweb_1.client,
+                }),
+                // injected(),
+                // coinbaseWallet({ appName: "HypeDuel" }),
+            ],
+        });
+    }, [rpcUrlsString, ecocystemConfig]);
+    return wagmiConfig;
+}

package/dist/cjs/global-account/react/stores/useModalStore.d.ts

@@ -32,8 +32,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/dist/cjs/notifications/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./types";
+export * from "./services";
+export { getAuthToken } from "../shared/utils/auth-token";

package/dist/cjs/notifications/index.js

@@ -0,0 +1,25 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getAuthToken = void 0;
+// Export types
+__exportStar(require("./types"), exports);
+// Export services
+__exportStar(require("./services"), exports);
+// Re-export auth token getter from shared for convenience
+// Note: Auth token is managed by B3 Global Account authentication
+var auth_token_1 = require("../shared/utils/auth-token");
+Object.defineProperty(exports, "getAuthToken", { enumerable: true, get: function () { return auth_token_1.getAuthToken; } });

package/dist/cjs/notifications/react/hooks/index.d.ts

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

package/dist/cjs/notifications/react/hooks/index.js

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./useNotifications"), exports);

package/dist/cjs/notifications/react/hooks/useNotifications.d.ts

@@ -0,0 +1,42 @@
+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 '../../../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 declare function useNotifications(): {
+    user: UserData | null;
+    loading: boolean;
+    error: Error | null;
+    refresh: () => Promise<void>;
+    connectEmail: (email: string) => Promise<void>;
+    connectTelegram: () => Promise<void>;
+    updateChannel: (channelId: string, updates: {
+        enabled?: boolean;
+    }) => Promise<void>;
+    deleteChannel: (channelId: string) => Promise<void>;
+    isEmailConnected: boolean;
+    isTelegramConnected: boolean;
+    isDiscordConnected: boolean;
+};

package/dist/cjs/notifications/react/hooks/useNotifications.js

@@ -0,0 +1,148 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useNotifications = useNotifications;
+const react_1 = require("react");
+const api_1 = require("../../services/api");
+/**
+ * React hook for managing B3 notifications
+ * Automatically uses the authenticated user's ID from JWT
+ *
+ * @example
+ * ```tsx
+ * import { useNotifications } from '../../../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>
+ *   );
+ * }
+ * ```
+ */
+function useNotifications() {
+    const [user, setUser] = (0, react_1.useState)(null);
+    const [loading, setLoading] = (0, react_1.useState)(true);
+    const [error, setError] = (0, react_1.useState)(null);
+    // Refs to track polling timers for cleanup
+    const telegramPollIntervalRef = (0, react_1.useRef)(null);
+    const telegramPollTimeoutRef = (0, react_1.useRef)(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
+    (0, react_1.useEffect)(() => {
+        loadUser();
+    }, []);
+    // Cleanup polling on unmount
+    (0, react_1.useEffect)(() => {
+        return () => {
+            cleanupTelegramPolling();
+        };
+    }, []);
+    const loadUser = async () => {
+        try {
+            setLoading(true);
+            setError(null);
+            const userData = await api_1.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) => {
+        try {
+            await api_1.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 api_1.notificationsAPI.getTelegramLink();
+            window.open(deepLink, "_blank");
+            // Poll for connection status
+            telegramPollIntervalRef.current = setInterval(async () => {
+                try {
+                    const { connected } = await api_1.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, updates) => {
+        try {
+            await api_1.notificationsAPI.updateChannel(channelId, updates);
+            await loadUser(); // Refresh user data
+        }
+        catch (err) {
+            console.error("Failed to update channel:", err);
+            throw err;
+        }
+    };
+    const deleteChannel = async (channelId) => {
+        try {
+            await api_1.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/dist/cjs/notifications/react/index.d.ts

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

package/dist/cjs/notifications/react/index.js

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./hooks"), exports);

package/dist/cjs/notifications/services/api.d.ts

@@ -0,0 +1,67 @@
+import type { NotificationHistory, NotificationPreferences, SendNotificationRequest, TelegramLinkResponse, TelegramStatusResponse, UserData } from "../types";
+export declare function setApiUrl(url: string): void;
+export declare function getApiUrl(): string;
+export declare const notificationsAPI: {
+    /**
+     * Register the current user (userId extracted from JWT)
+     */
+    registerUser(): Promise<any>;
+    /**
+     * Get current user's profile and preferences
+     */
+    getUser(): Promise<UserData>;
+    /**
+     * Get current user's notification history
+     */
+    getHistory(appId?: string, limit?: number): Promise<NotificationHistory[]>;
+    /**
+     * Add a notification channel for current user
+     */
+    addChannel(channelType: string, channelIdentifier: string, metadata?: Record<string, any>): Promise<any>;
+    /**
+     * Connect email for current user
+     */
+    connectEmail(email: string): Promise<any>;
+    /**
+     * Update a notification channel
+     */
+    updateChannel(channelId: string, updates: {
+        enabled?: boolean;
+        channelIdentifier?: string;
+        metadata?: Record<string, any>;
+    }): Promise<any>;
+    /**
+     * Delete a notification channel
+     */
+    deleteChannel(channelId: string): Promise<any>;
+    /**
+     * Get Telegram deep link for current user
+     */
+    getTelegramLink(): Promise<TelegramLinkResponse>;
+    /**
+     * Check current user's Telegram connection status
+     */
+    checkTelegramStatus(): Promise<TelegramStatusResponse>;
+    /**
+     * Save notification preferences for an app
+     * @param appId - The application ID
+     * @param settings - Notification preferences including channels, type, and enabled status (defaults to true)
+     */
+    savePreferences(appId: string, settings: NotificationPreferences): Promise<any>;
+    /**
+     * Get notification settings for an app
+     */
+    getAppSettings(appId: string): Promise<any>;
+    /**
+     * Get current user's in-app notifications
+     */
+    getInAppNotifications(): Promise<any>;
+    /**
+     * Mark a notification as read
+     */
+    markNotificationAsRead(notificationId: string): Promise<any>;
+    /**
+     * Send a notification (requires auth)
+     */
+    sendNotification(data: SendNotificationRequest): Promise<any>;
+};