@monygroupcorp/micro-web3 1.2.1 → 1.2.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@monygroupcorp/micro-web3",
-  "version": "1.2.1",
+  "version": "1.2.3",
   "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/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');
             }
@@ -490,7 +566,58 @@ class WalletService {
             signer: this.signer
         };
     }
-    
+
+    /**
+     * Programmatically set the connected state.
+     * Useful for migrating from manual workarounds or external connection management.
+     *
+     * @param {Object} state - The connection state to set
+     * @param {string} state.address - The connected wallet address
+     * @param {Object} state.provider - The raw provider (window.ethereum or similar)
+     * @param {Object} [state.ethersProvider] - Optional ethers Web3Provider (created if not provided)
+     * @param {Object} [state.signer] - Optional ethers signer (created if not provided)
+     * @param {string} [state.walletType='metamask'] - The wallet type identifier
+     * @param {boolean} [emitEvent=true] - Whether to emit wallet:connected event
+     * @returns {void}
+     */
+    setConnectedState({ address, provider, ethersProvider, signer, walletType = 'metamask' }, emitEvent = true) {
+        if (!address) {
+            throw new Error('setConnectedState requires an address');
+        }
+        if (!provider) {
+            throw new Error('setConnectedState requires a provider');
+        }
+
+        // Update internal state
+        this.provider = provider;
+        this.connectedAddress = address;
+        this.connected = true;
+        this.selectedWallet = walletType;
+
+        // Create ethers provider/signer if not provided
+        this.ethersProvider = ethersProvider || new ethers.providers.Web3Provider(provider, 'any');
+        this.signer = signer || this.ethersProvider.getSigner();
+
+        // Set up event listeners for the provider
+        this.setupEventListeners();
+
+        // Store wallet type for future auto-reconnect
+        localStorage.setItem('ms2fun_lastWallet', walletType);
+
+        console.log('[WalletService] State set programmatically:', address);
+
+        // Emit event so UI components update
+        if (emitEvent) {
+            this.eventBus.emit('wallet:connected', {
+                address: this.connectedAddress,
+                walletType: this.selectedWallet,
+                provider: this.provider,
+                ethersProvider: this.ethersProvider,
+                signer: this.signer
+            });
+        }
+    }
+
     /**
      * Handle network changes
      * @private