@monygroupcorp/micro-web3 1.2.0 → 1.2.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@monygroupcorp/micro-web3",
-  "version": "1.2.0",
+  "version": "1.2.2",
   "description": "A lean, reusable Web3 toolkit with components for wallet connection, IPFS, and common Web3 UI patterns.",
   "main": "dist/micro-web3.cjs",
   "module": "dist/micro-web3.esm.js",

package/src/components/FloatingWalletButton/FloatingWalletButton.js

@@ -49,30 +49,31 @@ export class FloatingWalletButton extends Component {
             let isConnected = this.walletService.isConnected();
             let address = this.walletService.getAddress();
 
-            // If not connected, try to auto-reconnect to last used wallet
+            // If not connected, check if window.ethereum already has connected accounts
             if (!isConnected && typeof window.ethereum !== 'undefined') {
                 try {
-                    const lastWallet = localStorage.getItem('ms2fun_lastWallet');
-
-                    if (lastWallet) {
-                        // Check if that wallet has accounts (without prompting)
-                        const accounts = await window.ethereum.request({ method: 'eth_accounts' });
-                        const hasAccounts = accounts && accounts.length > 0;
-
-                        // Only try to reconnect if the last wallet has accounts
-                        if (hasAccounts) {
-                            try {
-                                await this.walletService.selectWallet(lastWallet);
-                                await this.walletService.connect();
-                                isConnected = this.walletService.isConnected();
-                                address = this.walletService.getAddress();
-
-                                if (isConnected) {
-                                    console.log('[FloatingWalletButton] Auto-reconnected to', lastWallet);
-                                }
-                            } catch (connectError) {
-                                console.log('[FloatingWalletButton] Auto-reconnect not possible');
+                    // eth_accounts returns already-authorized accounts without prompting
+                    const accounts = await window.ethereum.request({ method: 'eth_accounts' });
+                    const hasAccounts = accounts && accounts.length > 0;
+
+                    if (hasAccounts) {
+                        // Detect which wallet is active
+                        const walletType = this._detectWalletType();
+                        console.log('[FloatingWalletButton] Detected existing connection:', walletType, accounts[0]);
+
+                        try {
+                            await this.walletService.selectWallet(walletType);
+                            await this.walletService.connect();
+                            isConnected = this.walletService.isConnected();
+                            address = this.walletService.getAddress();
+
+                            if (isConnected) {
+                                console.log('[FloatingWalletButton] Auto-connected to existing session:', walletType);
+                                // Update lastWallet for future sessions
+                                localStorage.setItem('ms2fun_lastWallet', walletType);
                             }
+                        } catch (connectError) {
+                            console.log('[FloatingWalletButton] Could not auto-connect:', connectError.message);
                         }
                     }
                 } catch (error) {
@@ -91,6 +92,21 @@ export class FloatingWalletButton extends Component {
         }
     }
 
+    /**
+     * Detect which wallet type is currently active based on provider flags
+     */
+    _detectWalletType() {
+        if (typeof window.ethereum === 'undefined') return 'metamask';
+
+        // Check specific wallet flags (order matters - more specific first)
+        if (window.ethereum.isRabby) return 'rabby';
+        if (window.ethereum.isRainbow) return 'rainbow';
+        if (window.phantom?.ethereum) return 'phantom';
+
+        // Default to metamask for any EIP-1193 provider
+        return 'metamask';
+    }
+
     /**
      * Load wallet info (balance, EXEC tokens, vault benefactor status)
      */

package/src/services/WalletService.js

@@ -56,39 +56,108 @@ class WalletService {
     }
     
     /**
-     * Initialize the wallet service - just check for wallet presence
+     * Initialize the wallet service
+     * @param {Object} options - Initialization options
+     * @param {boolean} options.autoReconnect - If true, automatically reconnect to previously authorized wallets
+     * @returns {Promise<boolean>} True if initialized successfully
      */
-    async initialize() {
+    async initialize(options = {}) {
         try {
             console.log('Initializing WalletService...');
-            
+
             // Check if window.ethereum exists
             if (typeof window.ethereum !== 'undefined') {
                 // Log that we found a wallet provider
                 console.log('Found Ethereum provider');
-                
+
                 // Let other components know a wallet was detected
                 this.eventBus.emit('wallet:detected');
-                
+
                 // Check if the provider is in MetaMask compatibility mode
                 this.isMetaMask = window.ethereum.isMetaMask;
-                
+
                 // Set up event listeners for wallet changes
                 this.setupEventListeners();
             } else {
                 console.log('No Ethereum provider found');
                 this.eventBus.emit('wallet:notdetected');
             }
-            
+
             // Mark as initialized
             this.isInitialized = true;
-            
+
+            // Auto-reconnect if requested
+            if (options.autoReconnect) {
+                await this.tryAutoConnect();
+            }
+
             return true;
         } catch (error) {
             console.error('Error initializing WalletService:', error);
             throw error;
         }
     }
+
+    /**
+     * Attempt to auto-connect to a previously authorized wallet.
+     * Uses eth_accounts (non-prompting) to check for existing authorization.
+     * @returns {Promise<string|null>} The connected address, or null if no authorized wallet found
+     */
+    async tryAutoConnect() {
+        try {
+            if (typeof window.ethereum === 'undefined') {
+                return null;
+            }
+
+            // eth_accounts returns already-authorized accounts without prompting
+            const accounts = await window.ethereum.request({ method: 'eth_accounts' });
+
+            if (!accounts || accounts.length === 0) {
+                console.log('[WalletService] No previously authorized accounts found');
+                return null;
+            }
+
+            console.log('[WalletService] Found authorized account:', accounts[0]);
+
+            // Detect which wallet type is active
+            const walletType = this._detectWalletType();
+            console.log('[WalletService] Detected wallet type:', walletType);
+
+            // Select and connect (this won't prompt since already authorized)
+            await this.selectWallet(walletType);
+            const address = await this.connect();
+
+            console.log('[WalletService] Auto-reconnected to:', address);
+            return address;
+
+        } catch (error) {
+            console.warn('[WalletService] Auto-connect failed:', error.message);
+            return null;
+        }
+    }
+
+    /**
+     * Detect which wallet type is currently active based on provider flags
+     * @private
+     * @returns {string} The detected wallet type
+     */
+    _detectWalletType() {
+        if (typeof window.ethereum === 'undefined') return 'metamask';
+
+        // Check specific wallet flags (order matters - more specific first)
+        if (window.ethereum.isRabby) return 'rabby';
+        if (window.ethereum.isRainbow) return 'rainbow';
+        if (window.phantom?.ethereum) return 'phantom';
+
+        // Check localStorage for last used wallet as a hint
+        const lastWallet = localStorage.getItem('ms2fun_lastWallet');
+        if (lastWallet && this.providerMap[lastWallet]) {
+            return lastWallet;
+        }
+
+        // Default to metamask for any EIP-1193 provider
+        return 'metamask';
+    }
     
     /**
      * Format error to provide better context
@@ -287,11 +356,18 @@ class WalletService {
     }
     
     /**
-     * Connect to the selected wallet
-     * @returns {string} The connected address
+     * Connect to a wallet
+     * @param {string} [walletType] - Optional wallet type to connect to directly (e.g., 'metamask', 'rabby')
+     *                                If not provided, requires prior call to selectWallet()
+     * @returns {Promise<string>} The connected address
      */
-    async connect() {
+    async connect(walletType) {
         try {
+            // If walletType provided, select it first
+            if (walletType) {
+                await this.selectWallet(walletType);
+            }
+
             if (!this.selectedWallet || !this.provider) {
                 throw new Error('Please select a wallet first');
             }