signer-test-sdk-react 0.0.15 → 0.0.17

package/dist/src/AbstraxnProvider.js

@@ -97,6 +97,8 @@ function AbstraxnProviderInner({ config, children, base, wagmi }) {
     const [isExternalWalletConnected, setIsExternalWalletConnected] = useState(false);
     const [externalWalletAddress, setExternalWalletAddress] = useState(null);
     const [externalWalletChainId, setExternalWalletChainId] = useState(null);
+    // Connection type tracking: 'google' | 'email' | 'discord' | 'x' | 'passkey' | 'metamask' | 'walletconnect' | 'coinbase' | 'phantom' | 'injected' | null
+    const [connectionType, setConnectionType] = useState(null);
     const explicitConnectionRef = useRef(false);
     const autoDisconnectHandledRef = useRef(false);
     // Track when we last connected to prevent premature reset
@@ -161,6 +163,37 @@ function AbstraxnProviderInner({ config, children, base, wagmi }) {
                 setIsConnected(true);
                 setExternalWalletChainId(currentChainId);
                 setChainId(currentChainId);
+                // Restore connection type from connector
+                const connector = wagmiAccount.connector;
+                if (connector) {
+                    const connectorId = connector.id.toLowerCase();
+                    const connectorName = connector.name?.toLowerCase() || '';
+                    // Map connector to connection type
+                    if (connectorId.includes('metamask') || connectorId.includes('io.metamask') || connectorName.includes('metamask')) {
+                        setConnectionType('metamask');
+                    }
+                    else if (connectorId.includes('walletconnect') || connectorId.includes('wallet_connect') || connectorName.includes('walletconnect')) {
+                        setConnectionType('walletconnect');
+                    }
+                    else {
+                        // For other wallets (coinbase, phantom, injected), store as-is
+                        // The hook will normalize them, but we keep the original for reference
+                        const fallbackType = connectorName || connectorId;
+                        setConnectionType(fallbackType);
+                    }
+                }
+                else {
+                    // Try to restore from localStorage as fallback
+                    try {
+                        const storedType = localStorage.getItem('abstraxn_connection_type');
+                        if (storedType) {
+                            setConnectionType(storedType);
+                        }
+                    }
+                    catch (e) {
+                        // Ignore localStorage errors
+                    }
+                }
                 // Update refs to track the restored connection
                 lastAddressRef.current = walletAddress;
                 lastChainIdRef.current = currentChainId;
@@ -291,6 +324,18 @@ function AbstraxnProviderInner({ config, children, base, wagmi }) {
                 }
                 const cid = await walletInstance.getChainId();
                 setChainId(cid);
+                // Always restore connection type from localStorage on connect
+                // This ensures connectionType is available after OAuth redirects (Google, X, Discord)
+                // and after page refreshes
+                try {
+                    const storedType = localStorage.getItem('abstraxn_connection_type');
+                    if (storedType && (storedType === 'google' || storedType === 'email' || storedType === 'discord' || storedType === 'x' || storedType === 'passkey')) {
+                        setConnectionType(storedType);
+                    }
+                }
+                catch (e) {
+                    // Ignore localStorage errors
+                }
             }
             catch (err) {
                 console.error('Error getting wallet info on connect:', err);
@@ -320,6 +365,14 @@ function AbstraxnProviderInner({ config, children, base, wagmi }) {
             setUser(null);
             setWhoami(null);
             setChainId(null);
+            setConnectionType(null);
+            // Clear from localStorage
+            try {
+                localStorage.removeItem('abstraxn_connection_type');
+            }
+            catch (e) {
+                // Ignore localStorage errors
+            }
         });
         walletInstance.on('accountChanged', (newAddress) => {
             setAddress(newAddress);
@@ -350,6 +403,14 @@ function AbstraxnProviderInner({ config, children, base, wagmi }) {
                     if (!walletInstance)
                         throw new Error('Wallet not initialized');
                     const authManager = walletInstance.getAuthManager();
+                    const connectionTypeValue = 'email';
+                    setConnectionType(connectionTypeValue);
+                    try {
+                        localStorage.setItem('abstraxn_connection_type', connectionTypeValue);
+                    }
+                    catch (e) {
+                        // Ignore localStorage errors
+                    }
                     const result = await authManager.loginWithOTP(email);
                     otpIdRef.current = result.otpId;
                 }
@@ -364,6 +425,15 @@ function AbstraxnProviderInner({ config, children, base, wagmi }) {
                         throw new Error('Wallet not initialized');
                     if (!otpIdRef.current)
                         throw new Error('OTP ID not found');
+                    // Set connection type for email OTP before verification
+                    const connectionTypeValue = 'email';
+                    setConnectionType(connectionTypeValue);
+                    try {
+                        localStorage.setItem('abstraxn_connection_type', connectionTypeValue);
+                    }
+                    catch (e) {
+                        // Ignore localStorage errors
+                    }
                     const authManager = walletInstance.getAuthManager();
                     const user = await authManager.verifyOTP(otpIdRef.current, otp);
                     otpIdRef.current = null;
@@ -383,24 +453,57 @@ function AbstraxnProviderInner({ config, children, base, wagmi }) {
             onGoogleLogin: async () => {
                 if (!walletInstance)
                     throw new Error('Wallet not initialized');
+                const connectionTypeValue = 'google';
+                setConnectionType(connectionTypeValue);
+                // Store in localStorage for restoration
+                try {
+                    localStorage.setItem('abstraxn_connection_type', connectionTypeValue);
+                }
+                catch (e) {
+                    // Ignore localStorage errors
+                }
                 const authManager = walletInstance.getAuthManager();
                 await authManager.loginWithGoogle();
             },
             onTwitterLogin: async () => {
                 if (!walletInstance)
                     throw new Error('Wallet not initialized');
+                const connectionTypeValue = 'x';
+                setConnectionType(connectionTypeValue);
+                try {
+                    localStorage.setItem('abstraxn_connection_type', connectionTypeValue);
+                }
+                catch (e) {
+                    // Ignore localStorage errors
+                }
                 const authManager = walletInstance.getAuthManager();
                 await authManager.loginWithTwitter();
             },
             onDiscordLogin: async () => {
                 if (!walletInstance)
                     throw new Error('Wallet not initialized');
+                const connectionTypeValue = 'discord';
+                setConnectionType(connectionTypeValue);
+                try {
+                    localStorage.setItem('abstraxn_connection_type', connectionTypeValue);
+                }
+                catch (e) {
+                    // Ignore localStorage errors
+                }
                 const authManager = walletInstance.getAuthManager();
                 await authManager.loginWithDiscord();
             },
             onPasskeyLogin: async () => {
                 if (!walletInstance)
                     throw new Error('Wallet not initialized');
+                const connectionTypeValue = 'passkey';
+                setConnectionType(connectionTypeValue);
+                try {
+                    localStorage.setItem('abstraxn_connection_type', connectionTypeValue);
+                }
+                catch (e) {
+                    // Ignore localStorage errors
+                }
                 const authManager = walletInstance.getAuthManager();
                 const user = await authManager.loginWithPasskey();
                 // Set user immediately so onLoginSuccess can access it
@@ -411,6 +514,14 @@ function AbstraxnProviderInner({ config, children, base, wagmi }) {
             onPasskeySignup: async () => {
                 if (!walletInstance)
                     throw new Error('Wallet not initialized');
+                const connectionTypeValue = 'passkey';
+                setConnectionType(connectionTypeValue);
+                try {
+                    localStorage.setItem('abstraxn_connection_type', connectionTypeValue);
+                }
+                catch (e) {
+                    // Ignore localStorage errors
+                }
                 const authManager = walletInstance.getAuthManager();
                 const user = await authManager.signupWithPasskey();
                 // Set user immediately so onLoginSuccess can access it
@@ -421,6 +532,17 @@ function AbstraxnProviderInner({ config, children, base, wagmi }) {
             onLoginSuccess: async (data) => {
                 // Clear any previous errors on successful login
                 setError(null);
+                // Restore connection type from localStorage for OAuth logins (Google, X, Discord)
+                // This ensures connectionType is set after OAuth redirects
+                try {
+                    const storedType = localStorage.getItem('abstraxn_connection_type');
+                    if (storedType && (storedType === 'google' || storedType === 'x' || storedType === 'discord' || storedType === 'email' || storedType === 'passkey')) {
+                        setConnectionType(storedType);
+                    }
+                }
+                catch (e) {
+                    // Ignore localStorage errors
+                }
                 // Set user if provided in data
                 if (data.user) {
                     setUser(data.user);
@@ -967,6 +1089,16 @@ function AbstraxnProviderInner({ config, children, base, wagmi }) {
                     setUser(userInfo);
                     setWhoami(whoamiInfo);
                     setIsConnected(true);
+                    // Restore connection type from localStorage
+                    try {
+                        const storedType = localStorage.getItem('abstraxn_connection_type');
+                        if (storedType && (storedType === 'google' || storedType === 'email' || storedType === 'discord' || storedType === 'x' || storedType === 'passkey')) {
+                            setConnectionType(storedType);
+                        }
+                    }
+                    catch (e) {
+                        // Ignore localStorage errors
+                    }
                 }
             }
             catch (err) {
@@ -995,6 +1127,16 @@ function AbstraxnProviderInner({ config, children, base, wagmi }) {
                         }
                         const cid = await walletRef.current.getChainId();
                         setChainId(cid);
+                        // Restore connection type from localStorage
+                        try {
+                            const storedType = localStorage.getItem('abstraxn_connection_type');
+                            if (storedType && (storedType === 'google' || storedType === 'email' || storedType === 'discord' || storedType === 'x' || storedType === 'passkey')) {
+                                setConnectionType(storedType);
+                            }
+                        }
+                        catch (e) {
+                            // Ignore localStorage errors
+                        }
                     }
                     catch (restoreErr) {
                         console.error('Error restoring connection state:', restoreErr);
@@ -1064,6 +1206,14 @@ function AbstraxnProviderInner({ config, children, base, wagmi }) {
                     setIsExternalWalletConnected(false);
                     setExternalWalletAddress(null);
                     setExternalWalletChainId(null);
+                    setConnectionType(null);
+                    // Clear from localStorage
+                    try {
+                        localStorage.removeItem('abstraxn_connection_type');
+                    }
+                    catch (e) {
+                        // Ignore localStorage errors
+                    }
                     explicitConnectionRef.current = false;
                     lastConnectionTimeRef.current = 0;
                     // Always reset main isConnected when disconnecting external wallet
@@ -1087,6 +1237,14 @@ function AbstraxnProviderInner({ config, children, base, wagmi }) {
                     setIsConnected(false);
                     setAddress(null);
                     setChainId(null);
+                    setConnectionType(null);
+                    // Clear from localStorage
+                    try {
+                        localStorage.removeItem('abstraxn_connection_type');
+                    }
+                    catch (e) {
+                        // Ignore localStorage errors
+                    }
                     // console.log('✅ Abstraxn wallet disconnected, main state reset');
                 }
                 catch (err) {
@@ -1095,6 +1253,14 @@ function AbstraxnProviderInner({ config, children, base, wagmi }) {
                     setIsConnected(false);
                     setAddress(null);
                     setChainId(null);
+                    setConnectionType(null);
+                    // Clear from localStorage
+                    try {
+                        localStorage.removeItem('abstraxn_connection_type');
+                    }
+                    catch (e) {
+                        // Ignore localStorage errors
+                    }
                 }
             }
             // Final check: if neither wallet is connected, ensure main state is reset
@@ -1105,6 +1271,14 @@ function AbstraxnProviderInner({ config, children, base, wagmi }) {
                 setIsConnected(false);
                 setAddress(null);
                 setChainId(null);
+                setConnectionType(null);
+                // Clear from localStorage
+                try {
+                    localStorage.removeItem('abstraxn_connection_type');
+                }
+                catch (e) {
+                    // Ignore localStorage errors
+                }
                 // console.log('✅ Final check: All wallets disconnected, main state reset');
             }
             // Reset OTP screen and show initial login form
@@ -1344,6 +1518,14 @@ function AbstraxnProviderInner({ config, children, base, wagmi }) {
         setLoading(true);
         setError(null);
         try {
+            const connectionTypeValue = 'email';
+            setConnectionType(connectionTypeValue);
+            try {
+                localStorage.setItem('abstraxn_connection_type', connectionTypeValue);
+            }
+            catch (e) {
+                // Ignore localStorage errors
+            }
             const result = await walletRef.current.loginWithOTP(email);
             return result;
         }
@@ -1363,9 +1545,26 @@ function AbstraxnProviderInner({ config, children, base, wagmi }) {
         setLoading(true);
         setError(null);
         try {
+            // Set connection type for email OTP before verification
+            const connectionTypeValue = 'email';
+            setConnectionType(connectionTypeValue);
+            try {
+                localStorage.setItem('abstraxn_connection_type', connectionTypeValue);
+            }
+            catch (e) {
+                // Ignore localStorage errors
+            }
             const user = await walletRef.current.verifyOTP(otpId, otpCode);
             setIsConnected(true);
             setUser(user);
+            // Ensure connection type is set (in case connect event didn't restore it)
+            setConnectionType('email');
+            try {
+                localStorage.setItem('abstraxn_connection_type', 'email');
+            }
+            catch (e) {
+                // Ignore localStorage errors
+            }
             // Load whoami and address after verification
             try {
                 const whoamiInfo = await walletRef.current.getWhoami();
@@ -1395,6 +1594,14 @@ function AbstraxnProviderInner({ config, children, base, wagmi }) {
         setLoading(true);
         setError(null);
         try {
+            const connectionTypeValue = 'google';
+            setConnectionType(connectionTypeValue);
+            try {
+                localStorage.setItem('abstraxn_connection_type', connectionTypeValue);
+            }
+            catch (e) {
+                // Ignore localStorage errors
+            }
             await walletRef.current.loginWithGoogle();
             // Note: This will redirect, so loading state will be reset on callback
         }
@@ -1417,6 +1624,16 @@ function AbstraxnProviderInner({ config, children, base, wagmi }) {
             const user = await walletRef.current.handleGoogleCallback();
             if (user) {
                 setUser(user);
+                // Restore connection type for Google OAuth
+                try {
+                    const storedType = localStorage.getItem('abstraxn_connection_type');
+                    if (storedType === 'google') {
+                        setConnectionType('google');
+                    }
+                }
+                catch (e) {
+                    // Ignore localStorage errors
+                }
                 // handleGoogleCallback() already calls whoami and emits 'connect' event
                 // The 'connect' event handler will update whoami, address, and chainId
                 // So we don't need to do it here to avoid duplicate whoami calls
@@ -1738,6 +1955,41 @@ function AbstraxnProviderInner({ config, children, base, wagmi }) {
                 setIsExternalWalletConnected(true); // This marks it as an external wallet connection
                 setAddress(formattedAddress);
                 setIsConnected(true);
+                // Track connection type based on connector
+                const connector = wagmiAccount.connector;
+                if (connector) {
+                    const connectorId = connector.id.toLowerCase();
+                    const connectorName = connector.name?.toLowerCase() || '';
+                    let connectionTypeValue;
+                    // Map connector to connection type
+                    if (connectorId.includes('metamask') || connectorId.includes('io.metamask') || connectorName.includes('metamask')) {
+                        connectionTypeValue = 'metamask';
+                    }
+                    else if (connectorId.includes('walletconnect') || connectorId.includes('wallet_connect') || connectorName.includes('walletconnect')) {
+                        connectionTypeValue = 'walletconnect';
+                    }
+                    else if (connectorId.includes('coinbase') || connectorId.includes('com.coinbase') || connectorName.includes('coinbase')) {
+                        connectionTypeValue = 'coinbase';
+                    }
+                    else if (connectorId.includes('phantom') || connectorId.includes('app.phantom') || connectorName.includes('phantom')) {
+                        connectionTypeValue = 'phantom';
+                    }
+                    else if (connectorId.includes('injected')) {
+                        connectionTypeValue = 'injected';
+                    }
+                    else {
+                        // Use connector name or ID as fallback
+                        connectionTypeValue = connectorName || connectorId;
+                    }
+                    setConnectionType(connectionTypeValue);
+                    // Store in localStorage for restoration on refresh
+                    try {
+                        localStorage.setItem('abstraxn_connection_type', connectionTypeValue);
+                    }
+                    catch (e) {
+                        // Ignore localStorage errors
+                    }
+                }
                 if (currentChainId) {
                     setChainId(currentChainId);
                     setExternalWalletChainId(currentChainId);
@@ -1794,6 +2046,14 @@ function AbstraxnProviderInner({ config, children, base, wagmi }) {
             setIsExternalWalletConnected(false);
             setExternalWalletAddress(null);
             setExternalWalletChainId(null);
+            setConnectionType(null);
+            // Clear from localStorage
+            try {
+                localStorage.removeItem('abstraxn_connection_type');
+            }
+            catch (e) {
+                // Ignore localStorage errors
+            }
             explicitConnectionRef.current = false;
             lastConnectionTimeRef.current = 0;
             // CRITICAL: Reset refs so reconnect is detected as a new connection
@@ -1805,6 +2065,7 @@ function AbstraxnProviderInner({ config, children, base, wagmi }) {
             setIsConnected(false);
             setAddress(null);
             setChainId(null);
+            setConnectionType(null);
         }
         catch (err) {
             const error = err instanceof Error ? err : new Error('Failed to disconnect external wallet');
@@ -2108,6 +2369,8 @@ function AbstraxnProviderInner({ config, children, base, wagmi }) {
         availableChains,
         // Balance (for Abstraxn wallet)
         walletBalance: !isExternalWalletConnected ? walletBalance : undefined,
+        // Connection type
+        connectionType,
     };
     // Ref to store latest value to avoid dependency issues (defined after value)
     const valueRef = useRef(value);