shogun-core 1.2.7 → 1.2.8

package/dist/plugins/oauth/oauthPlugin.js

@@ -0,0 +1,302 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OAuthPlugin = void 0;
+const base_1 = require("../base");
+const oauthConnector_1 = require("./oauthConnector");
+const logger_1 = require("../../utils/logger");
+const errorHandler_1 = require("../../utils/errorHandler");
+/**
+ * OAuth Plugin for ShogunCore
+ * Provides authentication with external OAuth providers
+ */
+class OAuthPlugin extends base_1.BasePlugin {
+    name = "oauth";
+    version = "1.0.0";
+    description = "Provides OAuth authentication with external providers for ShogunCore";
+    oauthConnector = null;
+    config = {};
+    /**
+     * @inheritdoc
+     */
+    initialize(core) {
+        super.initialize(core);
+        // Initialize the OAuth connector
+        this.oauthConnector = new oauthConnector_1.OAuthConnector(this.config);
+        (0, logger_1.log)("OAuth plugin initialized successfully");
+    }
+    /**
+     * Configure the OAuth plugin with provider settings
+     * @param config - Configuration options for OAuth
+     */
+    configure(config) {
+        this.config = { ...this.config, ...config };
+        // If connector is already initialized, update its configuration
+        if (this.oauthConnector) {
+            this.oauthConnector.updateConfig(this.config);
+            (0, logger_1.log)("OAuth connector configuration updated", this.config.providers);
+        }
+    }
+    /**
+     * @inheritdoc
+     */
+    destroy() {
+        if (this.oauthConnector) {
+            this.oauthConnector.cleanup();
+        }
+        this.oauthConnector = null;
+        super.destroy();
+        (0, logger_1.log)("OAuth plugin destroyed");
+    }
+    /**
+     * Ensure that the OAuth connector is initialized
+     * @private
+     */
+    assertOAuthConnector() {
+        this.assertInitialized();
+        if (!this.oauthConnector) {
+            throw new Error("OAuth connector not initialized");
+        }
+        return this.oauthConnector;
+    }
+    /**
+     * @inheritdoc
+     */
+    isSupported() {
+        return this.assertOAuthConnector().isSupported();
+    }
+    /**
+     * @inheritdoc
+     */
+    getAvailableProviders() {
+        return this.assertOAuthConnector().getAvailableProviders();
+    }
+    /**
+     * @inheritdoc
+     */
+    async initiateOAuth(provider) {
+        (0, logger_1.log)(`Initiating OAuth flow with ${provider}`);
+        return this.assertOAuthConnector().initiateOAuth(provider);
+    }
+    /**
+     * @inheritdoc
+     */
+    async completeOAuth(provider, authCode, state) {
+        (0, logger_1.log)(`Completing OAuth flow with ${provider}`);
+        return this.assertOAuthConnector().completeOAuth(provider, authCode, state);
+    }
+    /**
+     * @inheritdoc
+     */
+    async generateCredentials(userInfo, provider) {
+        (0, logger_1.log)(`Generating credentials for ${provider} user`);
+        return this.assertOAuthConnector().generateCredentials(userInfo, provider);
+    }
+    /**
+     * Login with OAuth
+     * @param provider - OAuth provider to use
+     * @returns {Promise<AuthResult>} Authentication result
+     * @description Authenticates user using OAuth with external providers
+     */
+    async login(provider) {
+        (0, logger_1.log)(`OAuth login with ${provider}`);
+        try {
+            const core = this.assertInitialized();
+            (0, logger_1.log)(`OAuth login attempt with provider: ${provider}`);
+            if (!provider) {
+                throw (0, errorHandler_1.createError)(errorHandler_1.ErrorType.VALIDATION, "PROVIDER_REQUIRED", "OAuth provider required for OAuth login");
+            }
+            if (!this.isSupported()) {
+                throw (0, errorHandler_1.createError)(errorHandler_1.ErrorType.ENVIRONMENT, "OAUTH_UNAVAILABLE", "OAuth is not supported in this environment");
+            }
+            // Check if provider is available
+            const availableProviders = this.getAvailableProviders();
+            if (!availableProviders.includes(provider)) {
+                throw (0, errorHandler_1.createError)(errorHandler_1.ErrorType.VALIDATION, "PROVIDER_NOT_CONFIGURED", `Provider ${provider} is not configured or available`);
+            }
+            // Initiate OAuth flow with the provider
+            const oauthResult = await this.initiateOAuth(provider);
+            if (!oauthResult.success) {
+                throw (0, errorHandler_1.createError)(errorHandler_1.ErrorType.AUTHENTICATION, "OAUTH_INITIATION_FAILED", oauthResult.error || "Failed to initiate OAuth flow");
+            }
+            // In a browser environment, this would redirect to the OAuth provider
+            // The frontend should handle the redirect and then call handleOAuthCallback
+            // with the received code and state when the provider redirects back
+            // Return early with the auth URL that the frontend should use for redirection
+            return {
+                success: true,
+                redirectUrl: oauthResult.authUrl,
+                pendingAuth: true,
+                message: "Redirect to OAuth provider required to complete authentication",
+                provider,
+                authMethod: "oauth",
+            };
+        }
+        catch (error) {
+            // Handle both ShogunError and generic errors
+            const errorType = error?.type || errorHandler_1.ErrorType.AUTHENTICATION;
+            const errorCode = error?.code || "OAUTH_LOGIN_ERROR";
+            const errorMessage = error?.message || "Unknown error during OAuth login";
+            const handledError = errorHandler_1.ErrorHandler.handle(errorType, errorCode, errorMessage, error);
+            return {
+                success: false,
+                error: handledError.message,
+            };
+        }
+    }
+    /**
+     * Sign up with OAuth
+     * @param provider - OAuth provider to use
+     * @returns {Promise<AuthResult>} Registration result
+     * @description Creates a new user account using OAuth with external providers
+     */
+    async signUp(provider) {
+        (0, logger_1.log)(`OAuth signup with ${provider}`);
+        try {
+            const core = this.assertInitialized();
+            (0, logger_1.log)(`OAuth signup attempt with provider: ${provider}`);
+            if (!provider) {
+                throw (0, errorHandler_1.createError)(errorHandler_1.ErrorType.VALIDATION, "PROVIDER_REQUIRED", "OAuth provider required for OAuth signup");
+            }
+            if (!this.isSupported()) {
+                throw (0, errorHandler_1.createError)(errorHandler_1.ErrorType.ENVIRONMENT, "OAUTH_UNAVAILABLE", "OAuth is not supported in this environment");
+            }
+            // Check if provider is available
+            const availableProviders = this.getAvailableProviders();
+            if (!availableProviders.includes(provider)) {
+                throw (0, errorHandler_1.createError)(errorHandler_1.ErrorType.VALIDATION, "PROVIDER_NOT_CONFIGURED", `Provider ${provider} is not configured or available`);
+            }
+            // Initiate OAuth flow with the provider
+            const oauthResult = await this.initiateOAuth(provider);
+            if (!oauthResult.success) {
+                throw (0, errorHandler_1.createError)(errorHandler_1.ErrorType.AUTHENTICATION, "OAUTH_INITIATION_FAILED", oauthResult.error || "Failed to initiate OAuth flow");
+            }
+            // In a browser environment, this would redirect to the OAuth provider
+            // The frontend should handle the redirect and then call handleOAuthCallback
+            // with the received code and state when the provider redirects back
+            // Return early with the auth URL that the frontend should use for redirection
+            return {
+                success: true,
+                redirectUrl: oauthResult.authUrl,
+                pendingAuth: true,
+                message: "Redirect to OAuth provider required to complete registration",
+                provider,
+                authMethod: "oauth",
+            };
+        }
+        catch (error) {
+            // Handle both ShogunError and generic errors
+            const errorType = error?.type || errorHandler_1.ErrorType.AUTHENTICATION;
+            const errorCode = error?.code || "OAUTH_SIGNUP_ERROR";
+            const errorMessage = error?.message || "Unknown error during OAuth signup";
+            const handledError = errorHandler_1.ErrorHandler.handle(errorType, errorCode, errorMessage, error);
+            return {
+                success: false,
+                error: handledError.message,
+            };
+        }
+    }
+    /**
+     * Handle OAuth callback (for frontend integration)
+     * This method would be called when the OAuth provider redirects back
+     */
+    async handleOAuthCallback(provider, authCode, state) {
+        try {
+            (0, logger_1.log)(`Handling OAuth callback for ${provider}`);
+            const core = this.assertInitialized();
+            // Complete the OAuth flow
+            const result = await this.completeOAuth(provider, authCode, state);
+            if (!result.success || !result.userInfo) {
+                throw new Error(result.error || "Failed to complete OAuth flow");
+            }
+            // Generate credentials from user info
+            const credentials = await this.generateCredentials(result.userInfo, provider);
+            // Set authentication method
+            core.setAuthMethod("oauth");
+            // Login or sign up the user
+            const authResult = await this._loginOrSignUp(credentials.username, credentials.password);
+            if (authResult.success) {
+                // Store user info in user metadata
+                if (core.user) {
+                    await core.user.put({
+                        oauth: {
+                            provider,
+                            id: result.userInfo.id,
+                            email: result.userInfo.email,
+                            name: result.userInfo.name,
+                            picture: result.userInfo.picture,
+                            lastLogin: Date.now(),
+                        },
+                    });
+                }
+                // Emit appropriate event
+                const eventType = authResult.isNewUser ? "auth:signup" : "auth:login";
+                core.emit(eventType, {
+                    userPub: authResult.userPub,
+                    username: credentials.username,
+                    method: "oauth",
+                    provider,
+                });
+            }
+            return authResult;
+        }
+        catch (error) {
+            (0, logger_1.logError)(`Error handling OAuth callback for ${provider}:`, error);
+            return {
+                success: false,
+                error: error.message || "Failed to handle OAuth callback",
+            };
+        }
+    }
+    /**
+     * Private helper to login or sign up a user
+     */
+    async _loginOrSignUp(username, password) {
+        const core = this.assertInitialized();
+        if (!password) {
+            return {
+                success: false,
+                error: "Password not provided for login/signup.",
+            };
+        }
+        return new Promise((resolve) => {
+            // Check if user exists first to avoid race conditions
+            core.gun.get(`~@${username}`).once(async (data) => {
+                let authResult;
+                if (data) {
+                    // User exists, so log in
+                    (0, logger_1.log)(`User ${username} exists, attempting login.`);
+                    authResult = await core.login(username, password);
+                    authResult.isNewUser = false;
+                }
+                else {
+                    // User does not exist, so sign up
+                    (0, logger_1.log)(`User ${username} does not exist, attempting signup.`);
+                    authResult = await core.signUp(username, password);
+                    authResult.isNewUser = true;
+                }
+                resolve(authResult);
+            });
+        });
+    }
+    /**
+     * Alias for handleOAuthCallback for backward compatibility
+     * @deprecated Use handleOAuthCallback instead
+     */
+    async handleSimpleOAuth(provider, authCode, state) {
+        (0, logger_1.log)(`handleSimpleOAuth called (alias for handleOAuthCallback) for ${provider}`);
+        return this.handleOAuthCallback(provider, authCode, state);
+    }
+    /**
+     * Get cached user info for a user
+     */
+    getCachedUserInfo(userId, provider) {
+        return this.assertOAuthConnector().getCachedUserInfo(userId, provider);
+    }
+    /**
+     * Clear user info cache
+     */
+    clearUserCache(userId, provider) {
+        this.assertOAuthConnector().clearUserCache(userId, provider);
+    }
+}
+exports.OAuthPlugin = OAuthPlugin;

package/dist/plugins/oauth/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/plugins/web3/index.js

@@ -21,5 +21,6 @@ exports.web3Chain = void 0;
 __exportStar(require("./web3ConnectorPlugin"), exports);
 __exportStar(require("./types"), exports);
 __exportStar(require("./web3Connector"), exports);
+__exportStar(require("./web3Signer"), exports);
 var web3Chain_1 = require("./web3Chain");
 Object.defineProperty(exports, "web3Chain", { enumerable: true, get: function () { return __importDefault(web3Chain_1).default; } });

package/dist/plugins/web3/web3Chain.js

@@ -5,8 +5,14 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 const gun_1 = __importDefault(require("gun"));
 const web3Connector_1 = require("./web3Connector");
+const web3Signer_1 = require("./web3Signer");
 const web3Chain = () => {
     const web3 = new web3Connector_1.Web3Connector();
+    const signer = new web3Signer_1.Web3Signer(web3);
+    // Initialize the web3 chain object if it doesn't exist
+    if (!gun_1.default.chain.web3) {
+        gun_1.default.chain.web3 = {};
+    }
     gun_1.default.chain.web3.connect = async function () {
         return await web3.connectMetaMask();
     };
@@ -23,11 +29,80 @@ const web3Chain = () => {
         const signer = await web3.getSigner();
         return await signer.signMessage(message);
     };
-    gun_1.default.chain.verifySignature = async function (message, signature) {
+    gun_1.default.chain.web3.verifySignature = async function (message, signature) {
         return await web3.verifySignature(message, signature);
     };
-    gun_1.default.chain.isMetaMaskAvailable = function () {
+    gun_1.default.chain.web3.isMetaMaskAvailable = function () {
         return web3Connector_1.Web3Connector.isMetaMaskAvailable();
     };
+    /**
+     * Setup oneshot signing for an Ethereum address
+     * Creates signing credential with consistent password generation
+     */
+    gun_1.default.chain.web3.setupOneshotSigning = async function (address) {
+        return await signer.createSigningCredential(address);
+    };
+    /**
+     * Create authenticator for Web3 signing
+     * Returns a function that can be used with SEA.sign
+     */
+    gun_1.default.chain.web3.createAuthenticator = function (address) {
+        return signer.createAuthenticator(address);
+    };
+    /**
+     * Create derived key pair from Web3 credential
+     * Uses the same password generation as normal Web3 approach
+     */
+    gun_1.default.chain.web3.createDerivedKeyPair = async function (address, extra) {
+        return await signer.createDerivedKeyPair(address, extra);
+    };
+    /**
+     * Quick sign method that combines Web3 verification with derived key signing
+     * Similar to webauthn.js but for Web3
+     */
+    gun_1.default.chain.web3.quickSign = async function (data, address, extra) {
+        return await signer.signWithDerivedKeys(data, address, extra);
+    };
+    /**
+     * Creates a Gun user from Web3 signing credential
+     * Ensures SAME user as normal approach
+     */
+    gun_1.default.chain.web3.createGunUserFromSigningCredential = async function (address) {
+        return await signer.createGunUser(address, this);
+    };
+    /**
+     * Get the Gun user public key for a signing credential
+     */
+    gun_1.default.chain.web3.getGunUserPubFromSigningCredential = function (address) {
+        return signer.getGunUserPub(address);
+    };
+    /**
+     * Get the password (for consistency checking)
+     */
+    gun_1.default.chain.web3.getPassword = function (address) {
+        return signer.getPassword(address);
+    };
+    /**
+     * Verify consistency between oneshot and normal approaches
+     */
+    gun_1.default.chain.web3.verifyConsistency = async function (address, expectedUserPub) {
+        return await signer.verifyConsistency(address, expectedUserPub);
+    };
+    /**
+     * Complete consistent oneshot signing workflow
+     * Creates the SAME Gun user as normal approach
+     */
+    gun_1.default.chain.web3.setupConsistentOneshotSigning = async function (address) {
+        const credential = await signer.createSigningCredential(address);
+        const authenticator = signer.createAuthenticator(address);
+        const gunUser = await signer.createGunUser(address, this);
+        return {
+            credential,
+            authenticator,
+            gunUser,
+            username: credential.username,
+            password: credential.password,
+        };
+    };
 };
 exports.default = web3Chain;

package/dist/plugins/web3/web3Connector.js

@@ -31,33 +31,112 @@ class Web3Connector extends eventEmitter_1.EventEmitter {
         this.setupEventListeners();
     }
     /**
-     * Initialize the provider synchronously
+     * Initialize the provider synchronously with fallback mechanisms
+     * to handle conflicts between multiple wallet providers
      */
     initProvider() {
-        if (typeof window !== "undefined" && window.ethereum) {
+        if (typeof window !== "undefined") {
             try {
-                this.provider = new ethers_1.ethers.BrowserProvider(window.ethereum);
-                (0, logger_1.logDebug)("BrowserProvider initialized successfully");
+                // Check if ethereum is available from any provider
+                const ethereumProvider = this.getAvailableEthereumProvider();
+                if (ethereumProvider) {
+                    this.provider = new ethers_1.ethers.BrowserProvider(ethereumProvider);
+                    (0, logger_1.logDebug)("BrowserProvider initialized successfully");
+                }
+                else {
+                    (0, logger_1.logWarn)("No compatible Ethereum provider found");
+                }
             }
             catch (error) {
                 (0, logger_1.logError)("Failed to initialize BrowserProvider", error);
             }
         }
         else {
-            (0, logger_1.logWarn)("Window.ethereum is not available");
+            (0, logger_1.logWarn)("Window object not available (non-browser environment)");
+        }
+    }
+    /**
+     * Get available Ethereum provider from multiple possible sources
+     */
+    getAvailableEthereumProvider() {
+        if (typeof window === "undefined")
+            return undefined;
+        // Define provider sources with priority order
+        const providerSources = [
+            // Check if we have providers in the _ethereumProviders registry (from index.html)
+            {
+                source: () => window._ethereumProviders && window._ethereumProviders[0],
+                name: "Registry Primary",
+            },
+            { source: () => window.ethereum, name: "Standard ethereum" },
+            {
+                source: () => window.web3?.currentProvider,
+                name: "Legacy web3",
+            },
+            { source: () => window.metamask, name: "MetaMask specific" },
+            {
+                source: () => window.ethereum?.providers?.find((p) => p.isMetaMask),
+                name: "MetaMask from providers array",
+            },
+            {
+                source: () => window.ethereum?.providers?.[0],
+                name: "First provider in array",
+            },
+            // Try known provider names
+            {
+                source: () => window.enkrypt?.providers?.ethereum,
+                name: "Enkrypt",
+            },
+            {
+                source: () => window.coinbaseWalletExtension,
+                name: "Coinbase",
+            },
+            { source: () => window.trustWallet, name: "Trust Wallet" },
+            // Use special registry if available
+            {
+                source: () => Array.isArray(window._ethereumProviders)
+                    ? window._ethereumProviders.find((p) => !p._isProxy)
+                    : undefined,
+                name: "Registry non-proxy",
+            },
+        ];
+        // Try each provider source
+        for (const { source, name } of providerSources) {
+            try {
+                const provider = source();
+                if (provider && typeof provider.request === "function") {
+                    (0, logger_1.logDebug)(`Found compatible Ethereum provider: ${name}`);
+                    return provider;
+                }
+            }
+            catch (error) {
+                // Continue to next provider source
+                (0, logger_1.logWarn)(`Error checking provider ${name}:`, error);
+                continue;
+            }
         }
+        // No provider found
+        (0, logger_1.logWarn)("No compatible Ethereum provider found");
+        return undefined;
     }
     /**
      * Initialize the BrowserProvider (async method for explicit calls)
      */
     async setupProvider() {
         try {
-            if (typeof window !== "undefined" && window.ethereum) {
-                this.provider = new ethers_1.ethers.BrowserProvider(window.ethereum);
-                (0, logger_1.logDebug)("BrowserProvider initialized successfully");
+            if (typeof window !== "undefined") {
+                // Check if ethereum is available from any provider
+                const ethereumProvider = this.getAvailableEthereumProvider();
+                if (ethereumProvider) {
+                    this.provider = new ethers_1.ethers.BrowserProvider(ethereumProvider);
+                    (0, logger_1.logDebug)("BrowserProvider initialized successfully");
+                }
+                else {
+                    (0, logger_1.logWarn)("No compatible Ethereum provider found");
+                }
             }
             else {
-                (0, logger_1.logWarn)("Window.ethereum is not available");
+                (0, logger_1.logWarn)("Window object not available (non-browser environment)");
             }
         }
         catch (error) {
@@ -69,14 +148,25 @@ class Web3Connector extends eventEmitter_1.EventEmitter {
      */
     setupEventListeners() {
         if (this.provider) {
+            // Listen for network changes through ethers provider
             this.provider.on("network", (newNetwork, oldNetwork) => {
                 this.emit("chainChanged", newNetwork);
             });
-            // Listen for account changes
-            if (window.ethereum?.on) {
-                window.ethereum.on("accountsChanged", (accounts) => {
-                    this.emit("accountsChanged", accounts);
-                });
+            // Listen for account changes through the detected provider
+            try {
+                const ethereumProvider = this.getAvailableEthereumProvider();
+                if (ethereumProvider?.on) {
+                    ethereumProvider.on("accountsChanged", (accounts) => {
+                        this.emit("accountsChanged", accounts);
+                    });
+                    // Also listen for chainChanged events directly
+                    ethereumProvider.on("chainChanged", (chainId) => {
+                        this.emit("chainChanged", { chainId });
+                    });
+                }
+            }
+            catch (error) {
+                (0, logger_1.logWarn)("Failed to setup account change listeners", error);
             }
         }
     }
@@ -145,21 +235,40 @@ class Web3Connector extends eventEmitter_1.EventEmitter {
                     throw new Error("MetaMask is not available. Please install MetaMask extension.");
                 }
             }
+            // First check if we can get the provider
+            const ethereumProvider = this.getAvailableEthereumProvider();
+            if (!ethereumProvider) {
+                throw new Error("No compatible Ethereum provider found");
+            }
             // Richiedi esplicitamente l'accesso all'account MetaMask
             (0, logger_1.logDebug)("Requesting account access...");
             let accounts = [];
-            if (window.ethereum) {
-                try {
-                    accounts = await window.ethereum.request({
-                        method: "eth_requestAccounts",
-                    });
-                    (0, logger_1.logDebug)(`Accounts requested successfully: ${accounts.length} accounts returned`);
+            // Try multiple methods of requesting accounts for compatibility
+            try {
+                // Try the provider we found first
+                accounts = await ethereumProvider.request({
+                    method: "eth_requestAccounts",
+                });
+            }
+            catch (requestError) {
+                (0, logger_1.logWarn)("First account request failed, trying window.ethereum:", requestError);
+                // Fallback to window.ethereum if available and different
+                if (window.ethereum && window.ethereum !== ethereumProvider) {
+                    try {
+                        accounts = await window.ethereum.request({
+                            method: "eth_requestAccounts",
+                        });
+                    }
+                    catch (fallbackError) {
+                        (0, logger_1.logError)("All account request methods failed", fallbackError);
+                        throw new Error("User denied account access");
+                    }
                 }
-                catch (requestError) {
-                    (0, logger_1.logError)("Error requesting MetaMask accounts:", requestError);
+                else {
                     throw new Error("User denied account access");
                 }
             }
+            (0, logger_1.logDebug)(`Accounts requested successfully: ${accounts.length} accounts returned`);
             if (!accounts || accounts.length === 0) {
                 (0, logger_1.logDebug)("No accounts found, trying to get signer...");
             }
@@ -170,20 +279,22 @@ class Web3Connector extends eventEmitter_1.EventEmitter {
                     const address = await signer.getAddress();
                     if (!address) {
                         (0, logger_1.logError)("No address returned from signer");
-                        throw new Error("No accounts found in MetaMask");
+                        continue;
                     }
-                    (0, logger_1.logDebug)(`Signer address obtained: ${address}`);
-                    const metamaskUsername = `${address.toLowerCase()}`;
-                    // Emetti evento connesso
+                    (0, logger_1.logDebug)(`Successfully connected to MetaMask with address: ${address}`);
                     this.emit("connected", { address });
-                    (0, logger_1.logDebug)(`MetaMask connected successfully with address: ${address}`);
-                    return { success: true, address, username: metamaskUsername };
+                    return {
+                        success: true,
+                        address,
+                        message: "Successfully connected to MetaMask",
+                    };
                 }
                 catch (error) {
-                    (0, logger_1.logError)(`Error in connection attempt ${attempt}:`, error);
-                    if (attempt === this.config.maxRetries)
+                    (0, logger_1.logError)(`Attempt ${attempt} failed:`, error);
+                    if (attempt === this.config.maxRetries) {
                         throw error;
-                    (0, logger_1.logDebug)(`Retrying in ${this.config.retryDelay}ms...`);
+                    }
+                    // Wait before retrying
                     await new Promise((resolve) => setTimeout(resolve, this.config.retryDelay));
                 }
             }
@@ -262,10 +373,21 @@ class Web3Connector extends eventEmitter_1.EventEmitter {
      * @returns true if MetaMask is available
      */
     static isMetaMaskAvailable() {
-        const ethereum = window.ethereum;
-        return (typeof window !== "undefined" &&
-            typeof ethereum !== "undefined" &&
-            ethereum?.isMetaMask === true);
+        if (typeof window === "undefined")
+            return false;
+        // Check standard location
+        if (window.ethereum?.isMetaMask === true)
+            return true;
+        // Check alternate locations (for compatibility with multiple wallet extensions)
+        const alternateProviders = [
+            window.web3?.currentProvider,
+            window.metamask,
+        ];
+        for (const provider of alternateProviders) {
+            if (provider?.isMetaMask === true)
+                return true;
+        }
+        return false;
     }
     /**
      * Request signature using BrowserProvider
@@ -326,10 +448,10 @@ class Web3Connector extends eventEmitter_1.EventEmitter {
         });
     }
     /**
-     * Checks if MetaMask is available
+     * Checks if any Ethereum provider is available
      */
     isAvailable() {
-        return typeof window !== "undefined" && !!window.ethereum;
+        return (typeof window !== "undefined" && !!this.getAvailableEthereumProvider());
     }
     /**
      * Configure custom JSON-RPC provider