@b3dotfun/sdk 0.0.47-alpha.0 → 0.0.47-test.4

package/dist/esm/global-account/react/hooks/useAuthentication.d.ts

@@ -1,5 +1,6 @@
+import { Wallet } from "thirdweb/wallets";
 import { preAuthenticate } from "thirdweb/wallets/in-app";
-export declare function useAuthentication(partnerId: string, loginWithSiwe?: boolean): {
+export declare function useAuthentication(partnerId: string): {
     logout: (callback?: () => void) => Promise<void>;
     isAuthenticated: boolean;
     isReady: boolean;
@@ -7,6 +8,54 @@ export declare function useAuthentication(partnerId: string, loginWithSiwe?: boo
     isConnected: boolean;
     wallet: import("thirdweb/dist/types/wallets/in-app/core/wallet/types").EcosystemWallet;
     preAuthenticate: typeof preAuthenticate;
-    connect: (strategyOptions?: import("thirdweb/wallets").SingleStepAuthArgsType) => Promise<import("thirdweb/wallets").Wallet | null>;
+    connect: (wallet: Wallet) => Promise<void>;
     isAuthenticating: boolean;
+    onConnect: (wallet: Wallet) => Promise<void>;
+    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;
+    refetchUser: (wallet?: Wallet) => Promise<void>;
+    setUser: (newUser?: import("@b3dotfun/b3-api").Users) => void;
 };

package/dist/esm/global-account/react/hooks/useAuthentication.js

@@ -1,117 +1,149 @@
 import app from "../../../global-account/app.js";
 import { authenticateWithB3JWT } from "../../../global-account/bsmnt.js";
-import { useAuthStore, useB3 } from "../../../global-account/react/index.js";
+import { useAuthStore, useSiwe } from "../../../global-account/react/index.js";
 import { ecosystemWalletId } from "../../../shared/constants/index.js";
-import { b3MainnetThirdWeb } from "../../../shared/constants/chains/supported.js";
 import { debugB3React } from "../../../shared/utils/debug.js";
 import { client } from "../../../shared/utils/thirdweb.js";
-import { useEffect, useRef } from "react";
-import { useActiveWallet, useAutoConnect, useConnectedWallets, useDisconnect } from "thirdweb/react";
+import { getConnectors } from "@wagmi/core";
+import { useCallback, useEffect, useRef } from "react";
+import { useActiveWallet, useAutoConnect, useConnectedWallets, useDisconnect, useSetActiveWallet, } from "thirdweb/react";
 import { ecosystemWallet } from "thirdweb/wallets";
 import { preAuthenticate } from "thirdweb/wallets/in-app";
-import { useConnect } from "./useConnect.js";
-import { useSiwe } from "./useSiwe.js";
+import { useAccount, useConnect } from "wagmi";
+import { useUserQuery } from "./useUserQuery.js";
+import { useWagmiConfig } from "./useWagmiConfig.js";
 const debug = debugB3React("useAuthentication");
-export function useAuthentication(partnerId, loginWithSiwe) {
+export function useAuthentication(partnerId) {
     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();
+    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);
-                    return;
+    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 (twWallet &&
+                    // 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
+                        };
+                        debug("@@syncWagmi:connecting", { twWallet, connector });
+                        connect({
+                            connector,
+                            ...options,
+                        });
+                    }
+                    catch (error) {
+                        console.error("@@syncWagmi:error", error);
+                    }
                 }
-                debug("setIsAuthenticating:true:4");
-                const account = await wallet.getAccount();
-                if (!account) {
-                    throw new Error("No account found during auto-connect");
+                else {
+                    debug("@@syncWagmi:not-connecting", 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);
-                }
-            }
-            catch (error) {
-                debug("Auto-connect authentication failed", { error });
-                setIsAuthenticated(false);
-                debug("setIsAuthenticating:false:4");
-                setUser();
-            }
-            setIsAuthenticating(false);
-        },
-    });
-    /**
-     * useAutoConnectLoading starts as false
-     */
+            });
+        }
+        syncWagmiFunc();
+        // wagmi config shouldn't change
+        // eslint-disable-next-line react-hooks/exhaustive-deps
+    }, [partnerId, wallets]);
     useEffect(() => {
-        if (!useAutoConnectLoading && useAutoConnectLoadingPrevious.current && !hasStartedConnecting) {
+        syncWagmi();
+    }, [wallets, syncWagmi]);
+    const authenticateUser = useCallback(async (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);
         }
-        useAutoConnectLoadingPrevious.current = useAutoConnectLoading;
-    }, [useAutoConnectLoading, hasStartedConnecting, setIsAuthenticating]);
-    // Ensure isAuthenticating stays true until we're fully ready
-    useEffect(() => {
-        if (useAutoConnectLoading) {
-            setIsConnecting(true);
+        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);
+            debug("@@b3Jwt", b3Jwt);
         }
-        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);
+    }, [activeWallet, partnerId, authenticate, setIsAuthenticated, setIsAuthenticating, setUser, setHasStartedConnecting]);
+    const onConnect = useCallback(async (wallet) => {
+        debug("@@useAuthentication:onConnect", { wallet });
+        try {
+            setHasStartedConnecting(true);
+            setIsConnected(true);
+            setIsAuthenticating(true);
+            await setActiveWallet(wallet);
+            await authenticateUser(wallet);
+        }
+        catch (error) {
+            debug("@@useAuthentication:onConnect:failed", { error });
+            setIsAuthenticated(false);
+            setUser(undefined);
         }
-        else {
-            debug("setIsAuthenticating:false:5b");
-            setIsConnecting(false);
+        finally {
+            setIsAuthenticating(false);
         }
-    }, [useAutoConnectLoading, isAuthenticated, setIsConnecting, setIsConnected]);
+        debug({
+            isAuthenticated,
+            isAuthenticating,
+            isConnected,
+        });
+    }, [
+        authenticateUser,
+        isAuthenticated,
+        isAuthenticating,
+        isConnected,
+        setActiveWallet,
+        setHasStartedConnecting,
+        setIsAuthenticated,
+        setIsAuthenticating,
+        setIsConnected,
+        setUser,
+    ]);
     const logout = async (callback) => {
         if (activeWallet) {
             debug("@@logout:activeWallet", activeWallet);
@@ -137,7 +169,21 @@ export function useAuthentication(partnerId, loginWithSiwe) {
         setUser();
         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,
         isAuthenticated,
@@ -146,7 +192,11 @@ export function useAuthentication(partnerId, loginWithSiwe) {
         isConnected,
         wallet,
         preAuthenticate,
-        connect,
+        connect: onConnect,
         isAuthenticating,
+        onConnect,
+        user,
+        refetchUser: authenticateUser,
+        setUser,
     };
 }

package/dist/esm/global-account/react/hooks/useHandleConnectWithPrivy.d.ts

@@ -4,7 +4,7 @@ import { Account } from "thirdweb/wallets";
  * This essentially wraps our useConnect hook to handle the Privy auth flow.
  * Currently, this is for the basement-privy strategy
  */
-export declare function useHandleConnectWithPrivy(partnerId: string, chain?: Chain, onSuccess?: (account: Account) => void): {
+export declare function useHandleConnectWithPrivy(chain?: Chain, onSuccess?: (account: Account) => void): {
     connectTw: () => Promise<import("thirdweb/wallets").Wallet | null | undefined>;
     isLoading: boolean;
     fullToken: string | null;

package/dist/esm/global-account/react/hooks/useHandleConnectWithPrivy.js

@@ -1,4 +1,4 @@
-import { useConnect } from "../../../global-account/react/index.js";
+import { useB3, useConnect } from "../../../global-account/react/index.js";
 import { debugB3React } from "../../../shared/utils/debug.js";
 import { useIdentityToken, usePrivy } from "@privy-io/react-auth";
 import { useCallback, useRef, useState } from "react";
@@ -7,7 +7,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, chain, onSuccess) {
+export function useHandleConnectWithPrivy(chain, onSuccess) {
+    const { partnerId } = useB3();
     if (!chain) {
         throw new Error("Chain is required");
     }

package/dist/esm/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/esm/global-account/react/hooks/useUserQuery.js

@@ -0,0 +1,83 @@
+import { debugB3React } from "../../../shared/utils/debug.js";
+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() {
+    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
+ */
+export function useUserQuery() {
+    const queryClient = useQueryClient();
+    // Query to get user data (primarily from cache/localStorage)
+    const { data: user } = 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 = 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/esm/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/esm/global-account/react/hooks/useWagmiConfig.js

@@ -0,0 +1,39 @@
+import { ecosystemWalletId } from "../../../shared/constants/index.js";
+import { supportedChains } from "../../../shared/constants/chains/supported.js";
+import { client } from "../../../shared/utils/thirdweb.js";
+import { inAppWalletConnector } from "@thirdweb-dev/wagmi-adapter";
+import { useMemo } from "react";
+import { http } from "viem";
+import { createConfig } from "wagmi";
+export 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 = 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/dist/esm/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/types/global-account/react/components/B3Provider/B3Provider.d.ts

@@ -19,12 +19,12 @@ export declare function B3Provider({ theme, children, accountOverride, environme
     };
     clientType?: ClientType;
     rpcUrls?: Record<number, string>;
-    partnerId?: string;
+    partnerId: string;
 }): import("react/jsx-runtime").JSX.Element;
 /**
  * Inner provider component that provides the actual B3Context
  */
-export declare function InnerProvider({ children, accountOverride, environment, defaultPermissions, automaticallySetFirstEoa, theme, clientType, }: {
+export declare function InnerProvider({ children, accountOverride, environment, defaultPermissions, automaticallySetFirstEoa, theme, clientType, partnerId, }: {
     children: React.ReactNode;
     accountOverride?: Account;
     environment: B3ContextType["environment"];
@@ -32,4 +32,5 @@ export declare function InnerProvider({ children, accountOverride, environment,
     automaticallySetFirstEoa: boolean;
     theme: "light" | "dark";
     clientType?: ClientType;
+    partnerId: string;
 }): import("react/jsx-runtime").JSX.Element;

package/dist/types/global-account/react/components/B3Provider/B3Provider.native.d.ts

@@ -5,21 +5,25 @@ import { B3ContextType } from "./types";
 /**
  * Main B3Provider component
  */
-export declare function B3Provider({ theme, children, accountOverride, environment, clientType, }: {
+export declare function B3Provider({ theme, children, accountOverride, environment, clientType, partnerId, rpcUrls, }: {
     theme: "light" | "dark";
     children: React.ReactNode;
     accountOverride?: Account;
     environment: B3ContextType["environment"];
     clientType?: ClientType;
+    partnerId: string;
+    rpcUrls?: Record<number, string>;
 }): import("react/jsx-runtime").JSX.Element;
 /**
  * Inner provider component that provides the actual B3Context
  */
-export declare function InnerProvider({ children, accountOverride, environment, defaultPermissions, theme, clientType, }: {
+export declare function InnerProvider({ children, accountOverride, environment, defaultPermissions, theme, clientType, partnerId, rpcUrls, }: {
     children: React.ReactNode;
     accountOverride?: Account;
     environment: B3ContextType["environment"];
     defaultPermissions?: PermissionsConfig;
     theme: "light" | "dark";
     clientType?: ClientType;
+    partnerId: string;
+    rpcUrls?: Record<number, string>;
 }): import("react/jsx-runtime").JSX.Element;

package/dist/types/global-account/react/components/B3Provider/types.d.ts

@@ -12,12 +12,14 @@ export interface B3ContextType {
     setWallet: (wallet: Wallet) => void;
     wallet?: Wallet;
     setUser: (user?: Users) => void;
+    refetchUser: () => Promise<any>;
     initialized: boolean;
     ready: boolean;
     environment?: "development" | "production";
     defaultPermissions?: PermissionsConfig;
     theme: "light" | "dark";
     clientType: ClientType;
+    partnerId: string;
 }
 /**
  * Context for B3 provider

package/dist/types/global-account/react/components/ManageAccount/BalanceContent.d.ts

@@ -1,8 +1,7 @@
 interface BalanceContentProps {
     onLogout?: () => void;
-    partnerId: string;
     showDeposit?: boolean;
     showSwap?: boolean;
 }
-export declare function BalanceContent({ onLogout, partnerId, showDeposit, showSwap }: BalanceContentProps): import("react/jsx-runtime").JSX.Element;
+export declare function BalanceContent({ onLogout, showDeposit, showSwap }: BalanceContentProps): import("react/jsx-runtime").JSX.Element;
 export {};

package/dist/types/global-account/react/components/SignInWithB3/SignInWithB3Flow.d.ts

@@ -3,4 +3,4 @@ import { SignInWithB3ModalProps } from "@b3dotfun/sdk/global-account/react";
  * Component that manages the authentication flow for Sign In With B3
  * Handles different login providers, authentication steps, and session key management
  */
-export declare function SignInWithB3Flow({ strategies, onLoginSuccess, onSessionKeySuccess, onError, chain, sessionKeyAddress, partnerId, closeAfterLogin, loginWithSiwe, source, signersEnabled, }: SignInWithB3ModalProps): import("react/jsx-runtime").JSX.Element | null;
+export declare function SignInWithB3Flow({ strategies, onLoginSuccess, onSessionKeySuccess, onError, chain, sessionKeyAddress, partnerId, closeAfterLogin, source, signersEnabled, }: SignInWithB3ModalProps): import("react/jsx-runtime").JSX.Element | null;