@b3dotfun/sdk 0.0.47-test.4 → 0.0.47

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

@@ -1,149 +1,117 @@
 import app from "../../../global-account/app.js";
 import { authenticateWithB3JWT } from "../../../global-account/bsmnt.js";
-import { useAuthStore, useSiwe } from "../../../global-account/react/index.js";
+import { useAuthStore, useB3 } 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 { getConnectors } from "@wagmi/core";
-import { useCallback, useEffect, useRef } from "react";
-import { useActiveWallet, useAutoConnect, useConnectedWallets, useDisconnect, useSetActiveWallet, } from "thirdweb/react";
+import { useEffect, useRef } from "react";
+import { useActiveWallet, useAutoConnect, useConnectedWallets, useDisconnect } from "thirdweb/react";
 import { ecosystemWallet } from "thirdweb/wallets";
 import { preAuthenticate } from "thirdweb/wallets/in-app";
-import { useAccount, useConnect } from "wagmi";
-import { useUserQuery } from "./useUserQuery.js";
-import { useWagmiConfig } from "./useWagmiConfig.js";
+import { useConnect } from "./useConnect.js";
+import { useSiwe } from "./useSiwe.js";
 const debug = debugB3React("useAuthentication");
-export function useAuthentication(partnerId) {
+export function useAuthentication(partnerId, loginWithSiwe) {
     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 isAuthenticating = useAuthStore(state => state.isAuthenticating);
+    const useAutoConnectLoadingPrevious = useRef(false);
     const setIsAuthenticating = useAuthStore(state => state.setIsAuthenticating);
-    const setHasStartedConnecting = useAuthStore(state => state.setHasStartedConnecting);
-    const setActiveWallet = useSetActiveWallet();
+    const isAuthenticating = useAuthStore(state => state.isAuthenticating);
     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 setHasStartedConnecting = useAuthStore(state => state.setHasStartedConnecting);
+    const { connect } = useConnect(partnerId, b3MainnetThirdWeb);
     const wallet = ecosystemWallet(ecosystemWalletId, {
         partnerId: partnerId,
     });
-    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);
-                    }
+    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;
                 }
-                else {
-                    debug("@@syncWagmi:not-connecting", connector);
+                debug("setIsAuthenticating:true:4");
+                const account = await wallet.getAccount();
+                if (!account) {
+                    throw new Error("No account found during auto-connect");
                 }
-            });
-        }
-        syncWagmiFunc();
-        // wagmi config shouldn't change
-        // eslint-disable-next-line react-hooks/exhaustive-deps
-    }, [partnerId, wallets]);
-    useEffect(() => {
-        syncWagmi();
-    }, [wallets, syncWagmi]);
-    const authenticateUser = useCallback(async (wallet) => {
-        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);
+                // 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);
-            debug("Re-authenticated successfully", { userAuth });
-            // Authenticate on BSMNT with B3 JWT
-            const b3Jwt = await authenticateWithB3JWT(userAuth.accessToken);
-            debug("@@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);
+        },
+    });
+    /**
+     * useAutoConnectLoading starts as false
+     */
+    useEffect(() => {
+        if (!useAutoConnectLoading && useAutoConnectLoadingPrevious.current && !hasStartedConnecting) {
             setIsAuthenticating(false);
-            debug("Fresh authentication successful", { userAuth });
-            // Authenticate on BSMNT with B3 JWT
-            const b3Jwt = await authenticateWithB3JWT(userAuth.accessToken);
-            debug("@@b3Jwt", b3Jwt);
         }
-    }, [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);
+        useAutoConnectLoadingPrevious.current = useAutoConnectLoading;
+    }, [useAutoConnectLoading, hasStartedConnecting, setIsAuthenticating]);
+    // Ensure isAuthenticating stays true until we're fully ready
+    useEffect(() => {
+        if (useAutoConnectLoading) {
+            setIsConnecting(true);
         }
-        catch (error) {
-            debug("@@useAuthentication:onConnect:failed", { error });
-            setIsAuthenticated(false);
-            setUser(undefined);
+        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);
         }
-        finally {
-            setIsAuthenticating(false);
+        else {
+            debug("setIsAuthenticating:false:5b");
+            setIsConnecting(false);
         }
-        debug({
-            isAuthenticated,
-            isAuthenticating,
-            isConnected,
-        });
-    }, [
-        authenticateUser,
-        isAuthenticated,
-        isAuthenticating,
-        isConnected,
-        setActiveWallet,
-        setHasStartedConnecting,
-        setIsAuthenticated,
-        setIsAuthenticating,
-        setIsConnected,
-        setUser,
-    ]);
+    }, [useAutoConnectLoading, isAuthenticated, setIsConnecting, setIsConnected]);
     const logout = async (callback) => {
         if (activeWallet) {
             debug("@@logout:activeWallet", activeWallet);
@@ -169,21 +137,7 @@ export function useAuthentication(partnerId) {
         setUser();
         callback?.();
     };
-    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;
+    const isReady = isAuthenticated && !useAutoConnectLoading && !isAuthenticating;
     return {
         logout,
         isAuthenticated,
@@ -192,11 +146,7 @@ export function useAuthentication(partnerId) {
         isConnected,
         wallet,
         preAuthenticate,
-        connect: onConnect,
+        connect,
         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(chain?: Chain, onSuccess?: (account: Account) => void): {
+export declare function useHandleConnectWithPrivy(partnerId: string, 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 { useB3, useConnect } from "../../../global-account/react/index.js";
+import { 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,8 +7,7 @@ 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(chain, onSuccess) {
-    const { partnerId } = useB3();
+export function useHandleConnectWithPrivy(partnerId, chain, onSuccess) {
     if (!chain) {
         throw new Error("Chain is required");
     }

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

@@ -32,6 +32,8 @@ 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, partnerId, }: {
+export declare function InnerProvider({ children, accountOverride, environment, defaultPermissions, automaticallySetFirstEoa, theme, clientType, }: {
     children: React.ReactNode;
     accountOverride?: Account;
     environment: B3ContextType["environment"];
@@ -32,5 +32,4 @@ 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,25 +5,21 @@ import { B3ContextType } from "./types";
 /**
  * Main B3Provider component
  */
-export declare function B3Provider({ theme, children, accountOverride, environment, clientType, partnerId, rpcUrls, }: {
+export declare function B3Provider({ theme, children, accountOverride, environment, clientType, }: {
     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, partnerId, rpcUrls, }: {
+export declare function InnerProvider({ children, accountOverride, environment, defaultPermissions, theme, clientType, }: {
     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,14 +12,12 @@ 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,7 +1,8 @@
 interface BalanceContentProps {
     onLogout?: () => void;
+    partnerId: string;
     showDeposit?: boolean;
     showSwap?: boolean;
 }
-export declare function BalanceContent({ onLogout, showDeposit, showSwap }: BalanceContentProps): import("react/jsx-runtime").JSX.Element;
+export declare function BalanceContent({ onLogout, partnerId, 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, source, signersEnabled, }: SignInWithB3ModalProps): import("react/jsx-runtime").JSX.Element | null;
+export declare function SignInWithB3Flow({ strategies, onLoginSuccess, onSessionKeySuccess, onError, chain, sessionKeyAddress, partnerId, closeAfterLogin, loginWithSiwe, source, signersEnabled, }: SignInWithB3ModalProps): import("react/jsx-runtime").JSX.Element | null;

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

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

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

@@ -9,6 +9,7 @@ interface LoginStepProps {
     /** 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 */
@@ -19,5 +20,5 @@ interface LoginStepContainerProps {
     partnerId?: string;
 }
 export declare function LoginStepContainer({ children, partnerId }: LoginStepContainerProps): import("react/jsx-runtime").JSX.Element;
-export declare function LoginStep({ onSuccess, chain }: LoginStepProps): import("react/jsx-runtime").JSX.Element;
+export declare function LoginStep({ onSuccess, onError, partnerId, chain }: LoginStepProps): import("react/jsx-runtime").JSX.Element;
 export {};

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

@@ -5,9 +5,10 @@ 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, chain, strategies, maxInitialWallets, automaticallySetFirstEoa, }: LoginStepCustomProps): import("react/jsx-runtime").JSX.Element;
+export declare function LoginStepCustom({ onSuccess, onError, partnerId, chain, strategies, maxInitialWallets, automaticallySetFirstEoa, }: LoginStepCustomProps): import("react/jsx-runtime").JSX.Element;
 export {};

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

@@ -1,6 +1,5 @@
-import { Wallet } from "thirdweb/wallets";
 import { preAuthenticate } from "thirdweb/wallets/in-app";
-export declare function useAuthentication(partnerId: string): {
+export declare function useAuthentication(partnerId: string, loginWithSiwe?: boolean): {
     logout: (callback?: () => void) => Promise<void>;
     isAuthenticated: boolean;
     isReady: boolean;
@@ -8,54 +7,6 @@ export declare function useAuthentication(partnerId: string): {
     isConnected: boolean;
     wallet: import("thirdweb/dist/types/wallets/in-app/core/wallet/types").EcosystemWallet;
     preAuthenticate: typeof preAuthenticate;
-    connect: (wallet: Wallet) => Promise<void>;
+    connect: (strategyOptions?: import("thirdweb/wallets").SingleStepAuthArgsType) => Promise<import("thirdweb/wallets").Wallet | null>;
     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/types/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(chain?: Chain, onSuccess?: (account: Account) => void): {
+export declare function useHandleConnectWithPrivy(partnerId: string, chain?: Chain, onSuccess?: (account: Account) => void): {
     connectTw: () => Promise<import("thirdweb/wallets").Wallet | null | undefined>;
     isLoading: boolean;
     fullToken: string | null;

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

@@ -32,6 +32,8 @@ 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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@b3dotfun/sdk",
-  "version": "0.0.47-test.4",
+  "version": "0.0.47",
   "source": "src/index.ts",
   "main": "./dist/cjs/index.js",
   "react-native": "./dist/cjs/index.native.js",
@@ -281,7 +281,7 @@
     "@solana/web3.js": "^1.98.2",
     "@stripe/react-stripe-js": "^3.7.0",
     "@stripe/stripe-js": "^7.3.1",
-    "@thirdweb-dev/wagmi-adapter": "0.2.159",
+    "@thirdweb-dev/wagmi-adapter": "^0.2.141",
     "@web3icons/react": "3.16.0",
     "big.js": "^7.0.1",
     "class-variance-authority": "0.7.0",
@@ -354,7 +354,7 @@
     "react": "^18.0.0 || ^19.0.0",
     "react-dom": "^18.0.0 || ^19.0.0",
     "react-native-mmkv": "^3.2.0",
-    "thirdweb": "5.108.9",
+    "thirdweb": "5.106.0",
     "three": "^0.175.0",
     "viem": "^2.28.1",
     "wagmi": "^2.14.15"