Fix MetaMask detection and improve error handling

- Fix unsafe window.web3.currentProvider access causing TypeError
- Add proper null checks for window.web3.currentProvider access
- Improve MetaMask detection timing with retry mechanism
- Add MutationObserver to watch for MetaMask injection
- Enhance error handling and logging for MetaMask detection
- Confirm MetaMask detection correctly checks active tab's window object
- Remove backup files from repository

content.js

@@ -492,7 +492,9 @@
         // Check for MetaMask specifically
         if (window['ethereum']) {
           ethereumProvider = window['ethereum'];
-        } else if (window['web3'] && window['web3'].currentProvider) {
+        } else if (window['web3'] &&
+                   window['web3'] !== null &&
+                   typeof window['web3'].currentProvider !== 'undefined') {
           ethereumProvider = window['web3'].currentProvider;
         }
       }

metamask-detector.js

@@ -22,29 +22,162 @@
 (function() {
   'use strict';
 
-  // Function to check if MetaMask is available
+  let metamaskDetected = false;
+  let metamaskProvider = null;
+  let detectionAttempts = 0;
+  const maxAttempts = 10;
+  const checkInterval = 500; // Check every 500ms
+
+  // Function to check if MetaMask is available with retry mechanism
   function isMetaMaskAvailable() {
-    const available = typeof window.ethereum !== 'undefined' ||
-           (typeof window.web3 !== 'undefined' && typeof window.web3.currentProvider !== 'undefined');
-    console.log('MetaMask detector: MetaMask available:', available);
-    return available;
+    // First check if we already detected it
+    if (metamaskDetected) {
+      console.log('MetaMask detector: MetaMask already detected');
+      return true;
+    }
+
+    // Check current state with proper null checks
+    const ethereumAvailable = typeof window.ethereum !== 'undefined';
+    const web3Available = typeof window.web3 !== 'undefined' &&
+                         window.web3 !== null &&
+                         typeof window.web3.currentProvider !== 'undefined';
+
+    const available = ethereumAvailable || web3Available;
+
+    if (available) {
+      metamaskDetected = true;
+      // Set provider with proper null checks
+      if (ethereumAvailable) {
+        metamaskProvider = window.ethereum;
+      } else if (web3Available) {
+        metamaskProvider = window.web3.currentProvider;
+      }
+      console.log('MetaMask detector: MetaMask detected on attempt', detectionAttempts);
+      return true;
+    }
+
+    // If not available and we haven't exceeded max attempts, schedule another check
+    if (detectionAttempts < maxAttempts) {
+      detectionAttempts++;
+      console.log('MetaMask detector: MetaMask not found, attempt', detectionAttempts, 'of', maxAttempts);
+      setTimeout(() => isMetaMaskAvailable(), checkInterval);
+    } else {
+      console.log('MetaMask detector: MetaMask not detected after', maxAttempts, 'attempts');
+    }
+
+    return false;
   }
 
   // Function to get MetaMask provider
   function getMetaMaskProvider() {
-    const provider = window.ethereum || window.web3.currentProvider;
+    if (metamaskProvider) {
+      return metamaskProvider;
+    }
+
+    // Try to get it directly with proper null checks
+    let provider = null;
+
+    if (typeof window.ethereum !== 'undefined') {
+      provider = window.ethereum;
+    } else if (typeof window.web3 !== 'undefined' &&
+               window.web3 !== null &&
+               typeof window.web3.currentProvider !== 'undefined') {
+      provider = window.web3.currentProvider;
+    }
+
+    if (provider) {
+      metamaskProvider = provider;
+    }
+
     console.log('MetaMask detector: Provider found:', !!provider);
     return provider;
   }
 
+  // Set up MutationObserver to watch for MetaMask injection
+  function setupMetaMaskWatcher() {
+    const observer = new MutationObserver((mutations) => {
+      // Check if ethereum was added to window
+      if (typeof window.ethereum !== 'undefined' && !metamaskDetected) {
+        console.log('MetaMask detector: ethereum object detected via MutationObserver');
+        metamaskDetected = true;
+        metamaskProvider = window.ethereum;
+      }
+
+      // Check if web3 was added to window with proper null checks
+      if (typeof window.web3 !== 'undefined' &&
+          window.web3 !== null &&
+          typeof window.web3.currentProvider !== 'undefined' &&
+          !metamaskDetected) {
+        console.log('MetaMask detector: web3 object detected via MutationObserver');
+        metamaskDetected = true;
+        metamaskProvider = window.web3.currentProvider;
+      }
+    });
+
+    // Start observing
+    observer.observe(document, {
+      childList: true,
+      subtree: true
+    });
+
+    console.log('MetaMask detector: MutationObserver set up to watch for MetaMask injection');
+  }
+
+  // Initialize detection
+  function initializeDetection() {
+    console.log('MetaMask detector: Initializing detection...');
+
+    // Start immediate check
+    isMetaMaskAvailable();
+
+    // Set up watcher for dynamic injection
+    setupMetaMaskWatcher();
+
+    // Also listen for ethereum#initialized event (MetaMask specific)
+    if (typeof window.ethereum !== 'undefined') {
+      window.ethereum.on('connect', () => {
+        console.log('MetaMask detector: ethereum connect event received');
+        metamaskDetected = true;
+        metamaskProvider = window.ethereum;
+      });
+    }
+  }
+
+  // Initialize on page load
+  if (document.readyState === 'loading') {
+    document.addEventListener('DOMContentLoaded', initializeDetection);
+  } else {
+    initializeDetection();
+  }
+
   // Listen for messages from popup
   chrome.runtime.onMessage.addListener((request, sender, sendResponse) => {
-    console.log('MetaMask detector: Received message:', request.action);
+    console.log('MetaMask detector: Received message:', request.action, 'from:', sender);
+
+    if (request.action === 'ping') {
+      console.log('MetaMask detector: Received ping, responding...');
+      sendResponse({ pong: true, source: 'metamask-detector' });
+    } else if (request.action === 'checkMetaMask') {
+      console.log('MetaMask detector: Processing checkMetaMask request');
 
-    if (request.action === 'checkMetaMask') {
+      // Immediate check for already detected MetaMask
+      if (metamaskDetected && metamaskProvider) {
+        console.log('MetaMask detector: MetaMask already detected, responding immediately');
+        const response = {
+          available: true,
+          provider: true,
+          source: 'metamask-detector'
+        };
+        sendResponse(response);
+        return;
+      }
+
+      // Force a fresh check
+      const available = isMetaMaskAvailable();
       const response = {
-        available: isMetaMaskAvailable(),
-        provider: getMetaMaskProvider() ? true : false
+        available: available,
+        provider: getMetaMaskProvider() ? true : false,
+        source: 'metamask-detector'
       };
       console.log('MetaMask detector: Sending response:', response);
       sendResponse(response);
@@ -72,6 +205,10 @@
 
       const ethereumProvider = getMetaMaskProvider();
 
+      if (!ethereumProvider) {
+        return { success: false, message: 'MetaMask provider not available.' };
+      }
+
       // Request account access
       let accounts;
       try {