Fix critical MetaMask provider conflicts and c.homedir errors - enhanced multi-provider support

Co-authored-by: 0xrinegade <[email protected]>

Author: Copilot

public/buffer-polyfill.js

@@ -183,7 +183,7 @@
       var global = window;
     }
 
-    // Add defensive handling for wallet extension conflicts
+    // Enhanced defensive handling for wallet extension conflicts
     (function() {
       try {
         // Store reference to any existing ethereum provider
@@ -193,39 +193,118 @@
         if (!window.ethereumHandlersInitialized) {
           window.ethereumHandlersInitialized = true;
 
-          // Create a non-conflicting ethereum property wrapper
-          Object.defineProperty(window, '_svmseekEthereumSafe', {
-            value: existingEthereum,
-            writable: false,
-            configurable: false
+          // Create a multiple provider management system
+          const providerRegistry = new Map();
+          let primaryProvider = existingEthereum;
+          
+          // Register existing provider if any
+          if (existingEthereum) {
+            if (existingEthereum.isMetaMask) {
+              providerRegistry.set('metamask', existingEthereum);
+            } else if (existingEthereum.isPhantom) {
+              providerRegistry.set('phantom', existingEthereum);
+            } else {
+              providerRegistry.set('unknown', existingEthereum);
+            }
+          }
+          
+          // Create a proxy ethereum object that can handle multiple providers
+          const ethereumProxy = new Proxy(primaryProvider || {}, {
+            get: function(target, prop) {
+              // Handle provider-specific access
+              if (prop === 'providers' && providerRegistry.size > 0) {
+                return Array.from(providerRegistry.values());
+              }
+              if (prop === 'getProvider') {
+                return function(name) {
+                  return providerRegistry.get(name) || primaryProvider;
+                };
+              }
+              if (prop === 'isMultiProvider') {
+                return providerRegistry.size > 1;
+              }
+              
+              // Delegate to primary provider or target
+              const provider = primaryProvider || target;
+              if (provider && typeof provider[prop] !== 'undefined') {
+                const value = provider[prop];
+                return typeof value === 'function' ? value.bind(provider) : value;
+              }
+              
+              return target[prop];
+            },
+            set: function(target, prop, value) {
+              if (primaryProvider) {
+                primaryProvider[prop] = value;
+              } else {
+                target[prop] = value;
+              }
+              return true;
+            }
           });
 
-          // Override Object.defineProperty to handle ethereum property conflicts
+          // Override Object.defineProperty to handle ethereum property conflicts gracefully
           const originalDefineProperty = Object.defineProperty;
           Object.defineProperty = function(obj, prop, descriptor) {
             if (obj === window && prop === 'ethereum') {
               try {
-                // If ethereum already exists and is non-configurable, skip redefinition
-                const existingDescriptor = Object.getOwnPropertyDescriptor(window, 'ethereum');
-                if (existingDescriptor && !existingDescriptor.configurable) {
-                  console.warn('SVMSeek: Skipping ethereum property redefinition to prevent conflicts');
-                  return obj;
+                // Check if we're dealing with a new provider
+                const newProvider = descriptor.value;
+                if (newProvider && typeof newProvider === 'object') {
+                  // Register the new provider
+                  let providerName = 'unknown';
+                  if (newProvider.isMetaMask) providerName = 'metamask';
+                  else if (newProvider.isPhantom) providerName = 'phantom';
+                  else if (newProvider.isSVMSeek) providerName = 'svmseek';
+                  else if (newProvider.isWalletConnect) providerName = 'walletconnect';
+                  
+                  providerRegistry.set(providerName, newProvider);
+                  
+                  // Update primary provider if this is the first or a preferred provider
+                  if (!primaryProvider || newProvider.isMetaMask) {
+                    primaryProvider = newProvider;
+                  }
+                  
+                  console.log('SVMSeek: Registered ethereum provider:', providerName);
+                  
+                  // Return the proxy instead of setting directly
+                  return originalDefineProperty.call(this, obj, prop, {
+                    value: ethereumProxy,
+                    writable: descriptor.writable,
+                    configurable: descriptor.configurable,
+                    enumerable: descriptor.enumerable
+                  });
                 }
 
-                // Allow the definition but catch any errors
+                // Allow the definition for non-provider values
                 return originalDefineProperty.call(this, obj, prop, descriptor);
               } catch (error) {
-                console.warn('SVMSeek: Prevented ethereum property conflict:', error.message);
+                console.warn('SVMSeek: Handled ethereum property conflict gracefully:', error.message);
+                // Don't throw, just log and continue
                 return obj;
               }
             }
             return originalDefineProperty.call(this, obj, prop, descriptor);
           };
 
-          console.log('SVMSeek: Ethereum property conflict protection enabled');
+          // Set initial ethereum proxy if we have providers
+          if (providerRegistry.size > 0 || primaryProvider) {
+            try {
+              originalDefineProperty.call(Object, window, 'ethereum', {
+                value: ethereumProxy,
+                writable: true,
+                configurable: true,
+                enumerable: true
+              });
+            } catch (error) {
+              console.warn('SVMSeek: Could not set initial ethereum proxy:', error.message);
+            }
+          }
+          
+          console.log('SVMSeek: Enhanced ethereum provider management enabled');
         }
       } catch (error) {
-        console.warn('SVMSeek: Failed to setup ethereum conflict protection:', error);
+        console.warn('SVMSeek: Failed to setup enhanced ethereum conflict protection:', error);
       }
     })();
 

src/polyfills/ultimate-fix.js

@@ -137,7 +137,7 @@ function setupSecureErrorHandling() {
       colno,
       error,
     ) {
-      // Handle homedir errors specifically
+      // Handle homedir errors specifically with enhanced recovery
       if (
         typeof message === 'string' &&
         (message.includes('c.homedir is not a function') ||
@@ -153,18 +153,54 @@ function setupSecureErrorHandling() {
       ) {
         logError('OS/Buffer access error intercepted:', message);
 
-        // Emergency polyfill injection
+        // Emergency polyfill injection with enhanced coverage
         try {
           if (typeof window !== 'undefined') {
             // Ensure os polyfill is available
             if (!window.os || !window.os.homedir) {
               window.os = osPolyfill;
             }
+            
             // Fix any undefined 'c' object that might be causing issues
             if (typeof window.c === 'undefined') {
-              window.c = { homedir: osPolyfill.homedir };
+              window.c = { 
+                homedir: osPolyfill.homedir,
+                resolve: function(...args) {
+                  // Basic path resolution for compatibility
+                  return args.join('/').replace(/\/+/g, '/');
+                }
+              };
             } else if (window.c && !window.c.homedir) {
               window.c.homedir = osPolyfill.homedir;
+              if (!window.c.resolve) {
+                window.c.resolve = function(...args) {
+                  return args.join('/').replace(/\/+/g, '/');
+                };
+              }
+            }
+            
+            // Also ensure global path resolution is available
+            if (!window.path) {
+              window.path = {
+                resolve: function(...args) {
+                  return args.join('/').replace(/\/+/g, '/');
+                },
+                join: function(...args) {
+                  return args.join('/').replace(/\/+/g, '/');
+                },
+                dirname: function(p) {
+                  return p.split('/').slice(0, -1).join('/') || '/';
+                },
+                basename: function(p) {
+                  return p.split('/').pop() || '';
+                }
+              };
+            }
+            
+            // Add to require cache if available
+            if (window.require && typeof window.require.cache === 'object') {
+              window.require.cache['os'] = { exports: window.os };
+              window.require.cache['path'] = { exports: window.path };
             }
           }
         } catch (recoveryError) {

src/services/WalletInjectionScript.ts

@@ -298,30 +298,50 @@ export function createWalletInjectionScript(): string {
     const phantomProvider = createWalletProvider('phantom');
     const svmseekProvider = createWalletProvider('svmseek');
 
+    // Check for existing providers to avoid conflicts
+    const existingProviders = {
+      solana: window.solana,
+      phantom: window.phantom,
+      svmseek: window.svmseek
+    };
+
     // Inject providers with proper property descriptors for security
-    Object.defineProperty(window, 'solana', {
-      value: solanaProvider,
-      writable: false,
-      configurable: false,
-      enumerable: true
-    });
+    // Only inject if not already present to avoid conflicts
+    if (!existingProviders.solana) {
+      Object.defineProperty(window, 'solana', {
+        value: solanaProvider,
+        writable: false,
+        configurable: false,
+        enumerable: true
+      });
+    } else {
+      console.warn('SVMSeek: Solana provider already exists, skipping injection');
+    }
 
-    Object.defineProperty(window, 'phantom', {
-      value: {
-        solana: phantomProvider,
-        isPhantom: true
-      },
-      writable: false,
-      configurable: false,
-      enumerable: true
-    });
+    if (!existingProviders.phantom) {
+      Object.defineProperty(window, 'phantom', {
+        value: {
+          solana: phantomProvider,
+          isPhantom: true
+        },
+        writable: false,
+        configurable: false,
+        enumerable: true
+      });
+    } else {
+      console.warn('SVMSeek: Phantom provider already exists, skipping injection');
+    }
 
-    Object.defineProperty(window, 'svmseek', {
-      value: svmseekProvider,
-      writable: false,
-      configurable: false,
-      enumerable: true
-    });
+    if (!existingProviders.svmseek) {
+      Object.defineProperty(window, 'svmseek', {
+        value: svmseekProvider,
+        writable: false,
+        configurable: false,
+        enumerable: true
+      });
+    } else {
+      console.warn('SVMSeek: SVMSeek provider already exists, skipping injection');
+    }
 
     // Mark injection as complete
     Object.defineProperty(window, 'svmseekWalletInjected', {
@@ -334,9 +354,9 @@ export function createWalletInjectionScript(): string {
     // Store provider references for external access
     Object.defineProperty(window, 'svmseekProviders', {
       value: {
-        solana: solanaProvider,
-        phantom: phantomProvider,
-        svmseek: svmseekProvider
+        solana: window.solana || solanaProvider,
+        phantom: window.phantom?.solana || phantomProvider,
+        svmseek: window.svmseek || svmseekProvider
       },
       writable: false,
       configurable: false,
@@ -348,11 +368,15 @@ export function createWalletInjectionScript(): string {
       detail: {
         version: '1.0.0',
         providers: ['solana', 'phantom', 'svmseek'],
-        timestamp: Date.now()
+        timestamp: Date.now(),
+        conflictsDetected: Object.values(existingProviders).some(p => p !== undefined)
       }
     }));
 
-    console.log('SVMSeek: Wallet providers injected successfully');
+    console.log('SVMSeek: Wallet providers injected successfully', {
+      conflictsDetected: Object.values(existingProviders).some(p => p !== undefined),
+      existingProviders: Object.keys(existingProviders).filter(key => existingProviders[key])
+    });
 
   } catch (error) {
     console.error('SVMSeek: Failed to inject wallet providers:', error);