@b3dotfun/sdk 0.0.1-alpha.1

package/dist/esm/global-account/react/components/SignInWithB3/SignInWithB3Flow.js

@@ -0,0 +1,200 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { useB3 } from "../../../../global-account/react/components/B3Provider";
+import { Loading } from "../../../../global-account/react/components/ui/Loading";
+import { useGetAllTWSigners } from "../../../../global-account/react/hooks/useGetAllTWSigners";
+import { useSiwe } from "../../../../global-account/react/hooks/useSiwe";
+import { useModalStore } from "../../../../global-account/react/stores/useModalStore";
+import { debugB3React } from "../../../../shared/utils/debug";
+import { useCallback, useEffect, useState } from "react";
+import { useActiveAccount } from "thirdweb/react";
+import { SignInWithB3Privy } from "./SignInWithB3Privy";
+import { LoginStep, LoginStepContainer } from "./steps/LoginStep";
+import { LoginStepCustom } from "./steps/LoginStepCustom";
+const debug = debugB3React("SignInWithB3Flow");
+const MAX_REFETCH_ATTEMPTS = 20;
+/**
+ * Component that manages the authentication flow for Sign In With B3
+ * Handles different login providers, authentication steps, and session key management
+ */
+export function SignInWithB3Flow({ strategies, onLoginSuccess, onSessionKeySuccess, onError, chain, sessionKeyAddress, partnerId, closeAfterLogin = false, loginWithSiwe = false, source = "signInWithB3Button", signersEnabled = false }) {
+    const { setUser, automaticallySetFirstEoa } = useB3();
+    const [step, setStep] = useState(source === "requestPermissions" ? null : "login");
+    const [sessionKeyAdded, setSessionKeyAdded] = useState(source === "requestPermissions" ? true : false);
+    const { setB3ModalContentType, setB3ModalOpen } = useModalStore();
+    const account = useActiveAccount();
+    const [loginComplete, setLoginComplete] = useState(source === "requestPermissions" ? true : false);
+    const [refetchCount, setRefetchCount] = useState(0);
+    const [refetchError, setRefetchError] = useState(null);
+    const { data: signers, refetch: refetchSigners, isFetching: isFetchingSigners } = useGetAllTWSigners({
+        chain,
+        accountAddress: account?.address,
+        queryOptions: {
+            enabled: signersEnabled
+        }
+    });
+    const { authenticate } = useSiwe();
+    const [authenticatingWithB3, setAuthenticatingWithB3] = useState(false);
+    const [refetchQueued, setRefetchQueued] = useState(false);
+    // Enhanced refetchSigners function that tracks number of attempts
+    const handleRefetchSigners = useCallback(() => {
+        if (refetchQueued) {
+            return;
+        }
+        if (refetchCount >= MAX_REFETCH_ATTEMPTS) {
+            setRefetchError(`Failed to fetch signers after ${MAX_REFETCH_ATTEMPTS} attempts`);
+            onError?.(new Error(`Failed to fetch signers after ${MAX_REFETCH_ATTEMPTS} attempts`));
+            return;
+        }
+        // Calculate backoff delay (100ms, 200ms, 400ms, 800ms, 1000ms, 1000ms...)
+        const backoffDelay = Math.min(Math.pow(2, refetchCount) * 100, 10000);
+        debug(`Retrying fetch (attempt ${refetchCount + 1}/${MAX_REFETCH_ATTEMPTS}) with ${backoffDelay}ms delay`);
+        // Increment count and schedule refetch with backoff
+        setRefetchCount(prev => prev + 1);
+        setRefetchQueued(true);
+        setTimeout(() => {
+            refetchSigners();
+            setRefetchQueued(false);
+        }, backoffDelay);
+    }, [refetchCount, refetchSigners, onError, setRefetchQueued, refetchQueued]);
+    // Handle post-login flow after signers are loaded
+    useEffect(() => {
+        debug("@@SignInWithB3Flow:useEffect", {
+            loginComplete,
+            isFetchingSigners,
+            source
+        });
+        if (loginComplete && !isFetchingSigners) {
+            // Check if we already have a signer for this partner
+            const hasExistingSigner = signers?.some(signer => signer.partner.id === partnerId);
+            if (hasExistingSigner) {
+                setSessionKeyAdded(true);
+                onSessionKeySuccess?.();
+                if (closeAfterLogin) {
+                    setB3ModalOpen(false);
+                }
+                else {
+                    setB3ModalContentType({
+                        type: "manageAccount",
+                        chain,
+                        partnerId
+                    });
+                }
+            }
+            else if (source !== "requestPermissions") {
+                if (signersEnabled)
+                    setStep("permissions");
+            }
+            else {
+                if (signersEnabled)
+                    handleRefetchSigners();
+            }
+            // Default handling
+            if (closeAfterLogin) {
+                setB3ModalOpen(false);
+            }
+            // if not closed, always default to manage account
+            setB3ModalContentType({
+                type: "manageAccount",
+                chain,
+                partnerId
+            });
+        }
+    }, [
+        signers,
+        isFetchingSigners,
+        partnerId,
+        loginComplete,
+        handleRefetchSigners,
+        source,
+        closeAfterLogin,
+        setB3ModalContentType,
+        chain,
+        onSessionKeySuccess,
+        setB3ModalOpen,
+        signersEnabled
+    ]);
+    debug("render", {
+        step,
+        strategies,
+        account,
+        signers,
+        refetchCount,
+        refetchError
+    });
+    // Keep this effect for handling closeAfterLogin when adding new session keys
+    useEffect(() => {
+        if (closeAfterLogin && sessionKeyAdded) {
+            setB3ModalOpen(false);
+        }
+    }, [closeAfterLogin, sessionKeyAdded, setB3ModalOpen]);
+    const onSessionKeySuccessEnhanced = useCallback(() => {
+        onSessionKeySuccess?.();
+        setB3ModalContentType({
+            type: "signInWithB3",
+            strategies,
+            onLoginSuccess,
+            onSessionKeySuccess,
+            onError,
+            chain,
+            sessionKeyAddress,
+            partnerId,
+            closeAfterLogin,
+            loginWithSiwe,
+            source: "requestPermissions"
+        });
+    }, [
+        chain,
+        closeAfterLogin,
+        loginWithSiwe,
+        onError,
+        onLoginSuccess,
+        onSessionKeySuccess,
+        partnerId,
+        sessionKeyAddress,
+        setB3ModalContentType,
+        strategies
+    ]);
+    const handleLoginSuccess = useCallback(async (account) => {
+        debug("Authenticating with B3 via SIWE");
+        if (loginWithSiwe) {
+            setAuthenticatingWithB3(true);
+            const userAuth = await authenticate(account);
+            setUser(userAuth.user);
+        }
+        debug("handleLoginSuccess:account", account);
+        onLoginSuccess?.(account);
+        setLoginComplete(true);
+        setAuthenticatingWithB3(false);
+    }, [authenticate, loginWithSiwe, onLoginSuccess, setUser]);
+    useEffect(() => {
+        if (step === "permissions") {
+            setB3ModalContentType({
+                type: "requestPermissions",
+                chain,
+                sessionKeyAddress,
+                onSuccess: onSessionKeySuccessEnhanced,
+                onError
+            });
+        }
+    }, [chain, onError, onSessionKeySuccessEnhanced, sessionKeyAddress, setB3ModalContentType, step]);
+    // Display error if refetch limit exceeded
+    if (refetchError) {
+        return (_jsx(LoginStepContainer, { partnerId: partnerId, children: _jsx("div", { className: "p-4 text-center text-red-500", children: refetchError }) }));
+    }
+    if (authenticatingWithB3 || (isFetchingSigners && step === "login") || source === "requestPermissions") {
+        return (_jsx(LoginStepContainer, { partnerId: partnerId, children: _jsx("div", { className: "mt-8 flex items-center justify-center", children: _jsx(Loading, { variant: "white", size: "lg" }) }) }));
+    }
+    if (step === "login") {
+        // Custom strategy
+        if (strategies?.[0] === "privy") {
+            return _jsx(SignInWithB3Privy, { onSuccess: handleLoginSuccess, partnerId: partnerId, chain: chain });
+        }
+        // Strategies are explicitly provided
+        if (strategies) {
+            return (_jsx(LoginStepCustom, { strategies: strategies, partnerId: partnerId, chain: chain, onSuccess: handleLoginSuccess, onError: onError, automaticallySetFirstEoa: !!automaticallySetFirstEoa }));
+        }
+        // Default to handle all strategies we support
+        return _jsx(LoginStep, { partnerId: partnerId, chain: chain, onSuccess: handleLoginSuccess, onError: onError });
+    }
+    return null;
+}

package/dist/esm/global-account/react/components/SignInWithB3/SignInWithB3Privy.d.ts

@@ -0,0 +1,11 @@
+import type { Chain } from "thirdweb";
+import { Account } from "thirdweb/wallets";
+interface SignInWithB3PrivyProps {
+    onError?: (error: Error) => Promise<void>;
+    onSuccess: (account: Account) => Promise<void>;
+    accessToken?: string;
+    partnerId: string;
+    chain: Chain;
+}
+export declare function SignInWithB3Privy({ onSuccess, onError, partnerId, chain }: SignInWithB3PrivyProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/esm/global-account/react/components/SignInWithB3/SignInWithB3Privy.js

@@ -0,0 +1,45 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { Loading } from "../../../../global-account/react/components/ui/Loading";
+import useAuthentication from "../../../../global-account/react/hooks/useAuthentication";
+import { useHandleConnectWithPrivy } from "../../../../global-account/react/hooks/useHandleConnectWithPrivy";
+import { useAuthStore } from "../../../../global-account/react/stores/useAuthStore";
+import { debugB3React } from "../../../../shared/utils/debug";
+import { useEffect } from "react";
+const debug = debugB3React("SignInWithB3Privy");
+export function SignInWithB3Privy({ onSuccess, onError, partnerId, chain }) {
+    const { isLoading, connectTw, fullToken } = useHandleConnectWithPrivy(partnerId, chain, onSuccess);
+    const setIsAuthenticating = useAuthStore(state => state.setIsAuthenticating);
+    const setIsAuthenticated = useAuthStore(state => state.setIsAuthenticated);
+    const { logout } = useAuthentication(partnerId);
+    debug("@@SignInWithB3Privy", {
+        isLoading,
+        fullToken
+    });
+    useEffect(() => {
+        async function autoConnect() {
+            try {
+                setIsAuthenticating(true);
+                const connectResult = await connectTw();
+                const account = connectResult?.getAccount();
+                if (!account) {
+                    setIsAuthenticated(false);
+                    return;
+                }
+                await onSuccess(account);
+                setIsAuthenticated(true);
+            }
+            catch (error) {
+                console.error("Failed to connect:", error);
+                await onError?.(error);
+                await logout();
+                setIsAuthenticated(false);
+            }
+            finally {
+                setIsAuthenticating(false);
+            }
+        }
+        autoConnect();
+    }, [connectTw, onSuccess, onError, setIsAuthenticating, setIsAuthenticated, logout]);
+    // Currently we auto login, so we can show loading immediately and the onSuccess will proceed to the next modal
+    return (_jsx("div", { className: "flex aspect-square items-center justify-center p-6", children: _jsx(Loading, { variant: "white", size: "lg" }) }));
+}

package/dist/esm/global-account/react/components/SignInWithB3/components/AuthButton.d.ts

@@ -0,0 +1,5 @@
+export default function AuthButton({ strategy, onClick, isLoading }: {
+    strategy: string;
+    onClick: () => void;
+    isLoading: boolean;
+}): import("react/jsx-runtime").JSX.Element;

package/dist/esm/global-account/react/components/SignInWithB3/components/AuthButton.js

@@ -0,0 +1,6 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { Button } from "../../custom/Button";
+import { strategyIcons } from "../utils/signInUtils";
+export default function AuthButton({ strategy, onClick, isLoading }) {
+    return (_jsx(Button, { onClick: onClick, disabled: isLoading, className: "flex w-full items-center justify-center bg-gray-100 px-2 py-3 hover:bg-gray-200 dark:bg-gray-800 dark:hover:bg-gray-700", children: _jsx("img", { src: strategyIcons[strategy], className: "h-9 w-9" }) }, strategy));
+}

package/dist/esm/global-account/react/components/SignInWithB3/components/PermissionItem.d.ts

@@ -0,0 +1,10 @@
+import type { JSX } from "react";
+import { ReactNode } from "react";
+interface PermissionItemProps {
+    title: string;
+    description: string | JSX.Element;
+    icon: string | ReactNode;
+    className?: string;
+}
+export declare function PermissionItem({ title, description, icon, className }: PermissionItemProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/esm/global-account/react/components/SignInWithB3/components/PermissionItem.js

@@ -0,0 +1,5 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { cn } from "../../../../../shared/utils";
+export function PermissionItem({ title, description, icon, className }) {
+    return (_jsxs("div", { className: cn("bg-b3-react-card flex items-center gap-5 rounded-lg border p-5 py-4", className), children: [_jsx("div", { className: "text-2xl opacity-30", children: icon }), _jsxs("div", { children: [_jsx("h3", { className: "text-lg font-medium", children: title }), _jsx("p", { className: "text-b3-react-muted-foreground text-sm opacity-70", children: description })] })] }));
+}

package/dist/esm/global-account/react/components/SignInWithB3/components/WalletRow.d.ts

@@ -0,0 +1,6 @@
+import { WalletId } from "thirdweb/wallets";
+export declare function WalletRow({ walletId, onClick, isLoading }: {
+    walletId: WalletId;
+    onClick: () => void;
+    isLoading: boolean;
+}): import("react/jsx-runtime").JSX.Element;

package/dist/esm/global-account/react/components/SignInWithB3/components/WalletRow.js

@@ -0,0 +1,6 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { WalletIcon, WalletName, WalletProvider } from "thirdweb/react";
+import { Button } from "../../custom/Button";
+export function WalletRow({ walletId, onClick, isLoading }) {
+    return (_jsx(WalletProvider, { id: walletId, children: _jsxs(Button, { onClick: onClick, disabled: isLoading, className: "flex w-full items-center justify-normal gap-3 rounded-lg border border-gray-200 bg-transparent px-4 py-3 text-gray-900 hover:bg-gray-100 dark:border-gray-700 dark:text-gray-100 dark:hover:bg-gray-800", children: [_jsx(WalletIcon, { className: "h-12 w-12", loadingComponent: _jsx("div", { className: "h-8 w-8 animate-pulse rounded-full bg-gray-200 dark:bg-gray-700" }) }), _jsx(WalletName, { className: "font-bold text-gray-900 dark:text-gray-100", loadingComponent: _jsx("div", { className: "h-4 w-24 animate-pulse rounded bg-gray-200 dark:bg-gray-700" }) })] }) }, walletId));
+}

package/dist/esm/global-account/react/components/SignInWithB3/steps/LoginStep.d.ts

@@ -0,0 +1,24 @@
+import { Chain } from "thirdweb";
+import { Account, SingleStepAuthArgsType } from "thirdweb/wallets";
+/**
+ * Props for the LoginStep component
+ */
+interface LoginStepProps {
+    /** Callback function called when login is successful */
+    onSuccess: (account: Account) => Promise<void>;
+    /** Optional callback function called when an error occurs */
+    onError?: (error: Error) => Promise<void>;
+    /** Partner ID used for authentication */
+    partnerId: string;
+    /** Blockchain chain information */
+    chain: Chain;
+    /** Optional authentication strategy options */
+    strategyOptions?: SingleStepAuthArgsType;
+}
+interface LoginStepContainerProps {
+    children: React.ReactNode;
+    partnerId?: string;
+}
+export declare function LoginStepContainer({ children, partnerId }: LoginStepContainerProps): import("react/jsx-runtime").JSX.Element;
+export declare function LoginStep({ onSuccess, onError, partnerId, chain }: LoginStepProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/esm/global-account/react/components/SignInWithB3/steps/LoginStep.js

@@ -0,0 +1,82 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useB3 } from "../../../../../global-account/react/components/B3Provider";
+import useAuthentication from "../../../../../global-account/react/hooks/useAuthentication";
+import useQueryB3 from "../../../../../global-account/react/hooks/useQueryB3";
+import { useAuthStore } from "../../../../../global-account/react/stores/useAuthStore";
+import { ecosystemWalletId } from "../../../../../shared/constants";
+import { client } from "../../../../../shared/utils/thirdweb";
+import { ConnectEmbed, darkTheme, lightTheme } from "thirdweb/react";
+import { ecosystemWallet } from "thirdweb/wallets";
+export function LoginStepContainer({ children, partnerId }) {
+    const { data: partner } = useQueryB3("global-accounts-partners", "find", {
+        query: {
+            partnerId,
+            $limit: 1
+        }
+    }, !!partnerId);
+    const partnerLogo = partner?.data?.[0]?.loginCustomization?.logoUrl;
+    return (_jsxs("div", { className: "flex flex-col items-center justify-center py-6", children: [partnerLogo && _jsx("img", { src: partnerLogo, alt: "Partner Logo", className: "mb-4 h-12 w-auto object-contain" }), children, _jsxs("h2", { className: "mt-3 flex items-center gap-2 text-lg font-bold", children: ["Powered by", _jsx("img", { alt: "B3 Logo", className: "h-5", src: "https://cdn.b3.fun/b3_logo.svg" }), "Connect"] })] }));
+}
+export function LoginStep({ onSuccess, onError, partnerId, chain }) {
+    const wallet = ecosystemWallet(ecosystemWalletId, {
+        partnerId: partnerId
+    });
+    const { theme } = useB3();
+    const setIsAuthenticating = useAuthStore(state => state.setIsAuthenticating);
+    const setIsAuthenticated = useAuthStore(state => state.setIsAuthenticated);
+    const { logout } = useAuthentication(partnerId);
+    return (_jsx(LoginStepContainer, { partnerId: partnerId, children: _jsx(ConnectEmbed, { showThirdwebBranding: false, client: client, chain: chain, wallets: [wallet], theme: theme === "light"
+                ? lightTheme({
+                    colors: {
+                        modalBg: "hsl(var(--b3-react-background))"
+                    }
+                })
+                : darkTheme({
+                    colors: {
+                        modalBg: "hsl(var(--b3-react-background))"
+                    }
+                }), autoConnect: true, style: {
+                width: "100%",
+                height: "100%",
+                border: 0
+            }, 
+            // TODO: Integrate with SIWE in useSIWE
+            // auth={{
+            //   isLoggedIn: async (address) => {
+            //     console.log("checking if logged in!", { address });
+            //     return await isLoggedIn();
+            //   },
+            //   doLogin: async (params) => {
+            //     console.log("logging in!");
+            //     await login(params);
+            //   },
+            //   getLoginPayload: async ({ address }) =>
+            //     generatePayload({ address }),
+            //   doLogout: async () => {
+            //     console.log("logging out!");
+            //     await logout();
+            //   },
+            // }}
+            header: {
+                title: "Sign in with B3",
+                titleIcon: "https://cdn.b3.fun/b3_logo.svg"
+            }, onConnect: async (wallet) => {
+                try {
+                    setIsAuthenticating(true);
+                    console.log("connected!", wallet);
+                    const account = wallet.getAccount();
+                    if (!account)
+                        throw new Error("No account found");
+                    await onSuccess(account);
+                    setIsAuthenticated(true);
+                }
+                catch (error) {
+                    await onError?.(error);
+                    await logout();
+                    setIsAuthenticated(false);
+                }
+                finally {
+                    setIsAuthenticating(false);
+                }
+            } }) }));
+}

package/dist/esm/global-account/react/components/SignInWithB3/steps/LoginStepCustom.d.ts

@@ -0,0 +1,14 @@
+import { AllowedStrategy } from "../../../../../global-account/react/components/SignInWithB3/utils/signInUtils";
+import { Chain } from "thirdweb";
+import { Account } from "thirdweb/wallets";
+interface LoginStepCustomProps {
+    automaticallySetFirstEoa: boolean;
+    onSuccess: (account: Account) => Promise<void>;
+    onError?: (error: Error) => Promise<void>;
+    partnerId: string;
+    chain: Chain;
+    strategies: AllowedStrategy[];
+    maxInitialWallets?: number;
+}
+export declare function LoginStepCustom({ onSuccess, onError, partnerId, chain, strategies, maxInitialWallets, automaticallySetFirstEoa }: LoginStepCustomProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/esm/global-account/react/components/SignInWithB3/steps/LoginStepCustom.js

@@ -0,0 +1,70 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Button } from "../../../../../global-account/react/components/custom/Button";
+import AuthButton from "../../../../../global-account/react/components/SignInWithB3/components/AuthButton";
+import { WalletRow } from "../../../../../global-account/react/components/SignInWithB3/components/WalletRow";
+import { LoginStepContainer } from "../../../../../global-account/react/components/SignInWithB3/steps/LoginStep";
+import { getConnectOptionsFromStrategy, isWalletType } from "../../../../../global-account/react/components/SignInWithB3/utils/signInUtils";
+import useAuthentication from "../../../../../global-account/react/hooks/useAuthentication";
+import { useConnect } from "../../../../../global-account/react/hooks/useConnect";
+import { useAuthStore } from "../../../../../global-account/react/stores/useAuthStore";
+import { client } from "../../../../../shared/utils/thirdweb";
+import { useState } from "react";
+import { useConnect as useConnectTW } from "thirdweb/react";
+import { createWallet } from "thirdweb/wallets";
+export function LoginStepCustom({ onSuccess, onError, partnerId, chain, strategies, maxInitialWallets = 2, automaticallySetFirstEoa }) {
+    const [isLoading, setIsLoading] = useState(false);
+    const [showAllWallets, setShowAllWallets] = useState(false);
+    const { connect } = useConnect(partnerId, chain);
+    const setIsAuthenticating = useAuthStore(state => state.setIsAuthenticating);
+    const setIsAuthenticated = useAuthStore(state => state.setIsAuthenticated);
+    const { logout } = useAuthentication(partnerId);
+    const { connect: connectTW } = useConnectTW();
+    // Split strategies into auth and wallet types
+    const authStrategies = strategies.filter(s => !isWalletType(s));
+    const walletStrategies = strategies.filter(isWalletType);
+    const initialWallets = walletStrategies.slice(0, maxInitialWallets);
+    const additionalWallets = walletStrategies.slice(maxInitialWallets);
+    const handleConnect = async (strategy) => {
+        try {
+            setIsLoading(true);
+            setIsAuthenticating(true);
+            const options = getConnectOptionsFromStrategy(strategy);
+            let connectResult;
+            if (automaticallySetFirstEoa) {
+                if (!options.wallet?.id) {
+                    throw new Error("Wallet ID is required");
+                }
+                connectResult = await connectTW(async () => {
+                    const wallet = createWallet(options.wallet?.id);
+                    await wallet.connect({
+                        client
+                    });
+                    return wallet;
+                });
+            }
+            else {
+                // @ts-expect-error we have custom strategies too and we also get things like "apple" isn't assignable to "wallet"
+                connectResult = await connect(options);
+            }
+            const account = connectResult?.getAccount();
+            console.log("@@gio:connectResult", { connectResult, account, options });
+            if (!account)
+                throw new Error("Failed to connect");
+            await onSuccess(account);
+            setIsAuthenticated(true);
+        }
+        catch (error) {
+            await onError?.(error);
+            await logout();
+            setIsAuthenticated(false);
+        }
+        finally {
+            setIsLoading(false);
+            setIsAuthenticating(false);
+        }
+    };
+    return (_jsxs(LoginStepContainer, { partnerId: partnerId, children: [authStrategies.length > 0 && (_jsx("div", { className: "mb-6 grid w-full grid-cols-4 gap-4", children: authStrategies.map(strategy => {
+                    console.log("strategy", strategy);
+                    return (_jsx(AuthButton, { strategy: strategy, onClick: () => handleConnect(strategy), isLoading: isLoading }, strategy));
+                }) })), _jsx("div", { className: "mb-4 w-full space-y-2", children: initialWallets.map(walletId => (_jsx(WalletRow, { walletId: walletId, onClick: () => handleConnect(walletId), isLoading: isLoading }, walletId))) }), additionalWallets.length > 0 && (_jsxs("div", { className: "w-full", children: [_jsx(Button, { onClick: () => setShowAllWallets(!showAllWallets), className: "mb-2 w-full bg-transparent text-gray-600 hover:bg-gray-100", children: showAllWallets ? "Show less" : "More options" }), showAllWallets && (_jsx("div", { className: "max-h-60 space-y-2 overflow-y-auto", children: additionalWallets.map(walletId => (_jsx(WalletRow, { walletId: walletId, onClick: () => handleConnect(walletId), isLoading: isLoading }, walletId))) }))] }))] }));
+}

package/dist/esm/global-account/react/components/SignInWithB3/utils/signInUtils.d.ts

@@ -0,0 +1,17 @@
+import { Chain } from "thirdweb";
+import { SingleStepAuthArgsType, Wallet } from "thirdweb/wallets";
+type WalletType = Wallet["id"];
+type StrategyType = SingleStepAuthArgsType["strategy"];
+type CustomStrategyType = "basement" | "privy";
+type AllowedStrategies = StrategyType | WalletType | CustomStrategyType;
+export declare const allowedStrategies: readonly ["apple", "google", "x", "discord", "guest", "walletConnect", "io.metamask", "com.coinbase.wallet", "basement", "privy"];
+export type AllowedStrategy = (typeof allowedStrategies)[number];
+export declare function isWalletType(strategy: AllowedStrategies): strategy is WalletType;
+export declare function isStrategyType(strategy: AllowedStrategies): strategy is StrategyType;
+export declare function getConnectOptionsFromStrategy(strategy: AllowedStrategy): {
+    strategy: StrategyType;
+    wallet?: Wallet;
+    chain?: Chain;
+};
+export declare const strategyIcons: Record<string, string>;
+export {};

package/dist/esm/global-account/react/components/SignInWithB3/utils/signInUtils.js

@@ -0,0 +1,50 @@
+import { createWallet } from "thirdweb/wallets";
+const customStrategies = ["basement", "privy"];
+// type CustomStrategy = (typeof customStrategies)[number];
+export const allowedStrategies = [
+    // Auth strategies
+    "apple",
+    "google",
+    "x",
+    "discord",
+    // "github",
+    "guest",
+    // Wallet IDs
+    "walletConnect",
+    "io.metamask",
+    "com.coinbase.wallet",
+    // Custom strategies
+    // TODO: Audit we don't use "privy" directly anymore
+    ...customStrategies
+];
+export function isWalletType(strategy) {
+    // Check if it's a known wallet ID pattern (com.*, io.*, etc.)
+    const walletIdPattern = /^(com\.|io\.|app\.|xyz\.|me\.|org\.|pro\.)/;
+    return strategy === "walletConnect" || walletIdPattern.test(strategy);
+}
+export function isStrategyType(strategy) {
+    return !isWalletType(strategy);
+}
+export function getConnectOptionsFromStrategy(strategy) {
+    if (!allowedStrategies.includes(strategy)) {
+        throw new Error(`Invalid strategy: ${strategy}`);
+    }
+    if (isWalletType(strategy)) {
+        return { strategy: "wallet", wallet: createWallet(strategy) };
+    }
+    else {
+        // @ts-expect-error we have custom strategies too
+        return { strategy };
+    }
+}
+export const strategyIcons = {
+    google: "https://cdn.b3.fun/google.svg",
+    x: "https://cdn.b3.fun/x.svg?1",
+    discord: "https://cdn.b3.fun/discord.svg",
+    apple: "https://cdn.b3.fun/apple.svg",
+    guest: "https://cdn.b3.fun/incognito.svg"
+    // Add more strategies as needed
+};
+// Test it
+// console.log(getConnectOptionsFromStrategy("io.metamask"));
+// console.log(getConnectOptionsFromStrategy("google"));

package/dist/esm/global-account/react/components/StyleRoot.d.ts

@@ -0,0 +1,4 @@
+import { PropsWithChildren } from "react";
+export default function StyleRoot({ children, id }: PropsWithChildren<{
+    id?: string;
+}>): import("react/jsx-runtime").JSX.Element;

package/dist/esm/global-account/react/components/StyleRoot.js

@@ -0,0 +1,7 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { useB3 } from "./B3Provider";
+export default function StyleRoot({ children, id }) {
+    const { theme: b3Theme } = useB3();
+    // eslint-disable-next-line tailwindcss/no-custom-classname
+    return (_jsx("div", { className: "b3-root", id: id, "data-theme": b3Theme, children: children }));
+}

package/dist/esm/global-account/react/components/Transak/TransakModal.d.ts

@@ -0,0 +1 @@
+export default function TransakModal(): import("react/jsx-runtime").JSX.Element;