@dynamic-labs/multi-wallet 0.17.0-RC.6 → 0.17.0-RC.8

package/src/wallets/ethereum/MagicConnector/MagicWalletConnector/MagicWalletConnector.cjs

@@ -6,10 +6,8 @@ var tslib = require('tslib');
 var magicSdk = require('magic-sdk');
 var ethers = require('ethers');
 var walletConnectorCore = require('@dynamic-labs/wallet-connector-core');
-var errors = require('../../../../errors.cjs');
-var logger = require('../../../../utils/logger.cjs');
+var utils = require('@dynamic-labs/utils');
 var assignConfirmationScreenToProvider = require('../../../../utils/assignConfirmationScreenToProvider/assignConfirmationScreenToProvider.cjs');
-var CancellablePromise = require('../../../../utils/CancellablePromise/CancellablePromise.cjs');
 var MagicClientNetworkHandler = require('../MagicClientNetworkHandler/MagicClientNetworkHandler.cjs');
 
 const storedAddressKey = 'dynamic_magic_address';
@@ -17,19 +15,25 @@ class MagicWalletConnector extends walletConnectorCore.WalletConnectorBase {
     get key() {
         return 'magiclink';
     }
-    constructor({ apiKey, walletUiUtils, evmNetworks, config, }) {
+    constructor(opts) {
+        var _a, _b, _c, _d;
         super();
         this.canConnectViaCustodialService = true;
         this.connectedChain = 'EVM';
         this.supportedChains = ['ETH', 'EVM'];
         this.name = 'Magic Link';
+        const apiKey = (_b = (_a = opts.apiProviders) === null || _a === void 0 ? void 0 : _a.magicLink) === null || _b === void 0 ? void 0 : _b.providerProjectId;
+        const defaultChainId = (_d = (_c = opts.apiProviders) === null || _c === void 0 ? void 0 : _c.magicLink) === null || _d === void 0 ? void 0 : _d.defaultChainId;
+        if (!apiKey) {
+            throw new Error('Missing MagicLink configuration. Add your MagicLink API key to your project configuration via the Dynamic Labs dashboard.');
+        }
         this._magicClient = new MagicClientNetworkHandler.MagicClientNetworkHandler({
-            config,
             createClient: (config) => new magicSdk.Magic(apiKey, config),
-            evmNetworks,
+            defaultChainId,
+            evmNetworks: opts.evmNetworks,
         });
-        this.evmNetworks = evmNetworks;
-        this._walletUiUtils = walletUiUtils;
+        this.evmNetworks = utils.parseEvmNetworks(opts.evmNetworks);
+        this._walletUiUtils = opts.walletUiUtils;
     }
     getDeepLink() {
         return undefined;
@@ -63,11 +67,11 @@ class MagicWalletConnector extends walletConnectorCore.WalletConnectorBase {
             const client = this._magicClient.getClient();
             try {
                 try {
-                    this._currentAuthCancellablePromise = CancellablePromise.CancellablePromise.fromPromise(this.loginWithMagic());
+                    this._currentAuthCancellablePromise = utils.CancellablePromise.fromPromise(this.loginWithMagic());
                     yield this._currentAuthCancellablePromise;
                 }
                 catch (err) {
-                    logger.logger.error(err);
+                    walletConnectorCore.logger.error(err);
                     return;
                 }
                 const metadata = yield client.user.getMetadata();
@@ -89,7 +93,7 @@ class MagicWalletConnector extends walletConnectorCore.WalletConnectorBase {
         return tslib.__awaiter(this, void 0, void 0, function* () {
             const provider = yield this.getWeb3Provider();
             if (!provider)
-                throw new errors.DynamicError('No provider');
+                throw new utils.DynamicError('No provider');
             const signer = provider.getSigner();
             const userAddress = yield signer.getAddress();
             return ethers.ethers.utils.formatEther(yield provider.getBalance(userAddress));

package/src/wallets/ethereum/MagicConnector/MagicWalletConnector/MagicWalletConnector.d.ts

@@ -2,14 +2,15 @@ import { LoginWithMagicLinkEvents, Magic, MagicUserMetadata, PromiEvent } from '
 import { ethers } from 'ethers';
 import { OAuthExtension, OAuthProvider } from '@magic-ext/oauth';
 import { Chain, WalletConnectorBase, WalletEventListeners } from '@dynamic-labs/wallet-connector-core';
-import { WalletUiUtils } from '../../../../types';
-import { CancellablePromise } from '../../../../utils/CancellablePromise';
-import { MagicLinkConfig, MagicClientNetworkHandler } from '../MagicClientNetworkHandler';
-import { EvmNetwork } from './../../evm-network';
+import { EvmNetwork, GenericNetwork, WalletUiUtils } from '@dynamic-labs/types';
+import { CancellablePromise } from '@dynamic-labs/utils';
+import { Provider, ProviderEnum } from '@dynamic-labs/sdk-api';
+import { MagicClientNetworkHandler } from '../MagicClientNetworkHandler';
 export type MagicConnectorProps = {
-    apiKey: string;
-    config?: MagicLinkConfig;
-    evmNetworks: EvmNetwork[];
+    apiProviders: {
+        [key in ProviderEnum]?: Provider;
+    };
+    evmNetworks: GenericNetwork[];
     walletUiUtils: WalletUiUtils;
 };
 export type MagicPromiEvent = PromiEvent<string | null, LoginWithMagicLinkEvents & {
@@ -28,7 +29,7 @@ export declare abstract class MagicWalletConnector extends WalletConnectorBase {
     _listeners: WalletEventListeners | undefined;
     _currentAuthCancellablePromise: CancellablePromise<MagicPromiEvent | undefined> | undefined;
     protected _magicClient: MagicClientNetworkHandler<Magic | Magic<OAuthExtension[]>>;
-    constructor({ apiKey, walletUiUtils, evmNetworks, config, }: MagicConnectorProps);
+    constructor(opts: MagicConnectorProps);
     abstract loginWithMagic(provider?: OAuthProvider): Promise<MagicPromiEvent | undefined>;
     getDeepLink(): string | undefined;
     connect(provider?: OAuthProvider): Promise<void>;

package/src/wallets/ethereum/MagicConnector/MagicWalletConnector/MagicWalletConnector.js

@@ -1,11 +1,9 @@
 import { __awaiter } from 'tslib';
 import { Magic } from 'magic-sdk';
 import { ethers } from 'ethers';
-import { WalletConnectorBase } from '@dynamic-labs/wallet-connector-core';
-import { DynamicError } from '../../../../errors.js';
-import { logger } from '../../../../utils/logger.js';
+import { WalletConnectorBase, logger } from '@dynamic-labs/wallet-connector-core';
+import { parseEvmNetworks, CancellablePromise, DynamicError } from '@dynamic-labs/utils';
 import { assignConfirmationScreenToProvider } from '../../../../utils/assignConfirmationScreenToProvider/assignConfirmationScreenToProvider.js';
-import { CancellablePromise } from '../../../../utils/CancellablePromise/CancellablePromise.js';
 import { MagicClientNetworkHandler } from '../MagicClientNetworkHandler/MagicClientNetworkHandler.js';
 
 const storedAddressKey = 'dynamic_magic_address';
@@ -13,19 +11,25 @@ class MagicWalletConnector extends WalletConnectorBase {
     get key() {
         return 'magiclink';
     }
-    constructor({ apiKey, walletUiUtils, evmNetworks, config, }) {
+    constructor(opts) {
+        var _a, _b, _c, _d;
         super();
         this.canConnectViaCustodialService = true;
         this.connectedChain = 'EVM';
         this.supportedChains = ['ETH', 'EVM'];
         this.name = 'Magic Link';
+        const apiKey = (_b = (_a = opts.apiProviders) === null || _a === void 0 ? void 0 : _a.magicLink) === null || _b === void 0 ? void 0 : _b.providerProjectId;
+        const defaultChainId = (_d = (_c = opts.apiProviders) === null || _c === void 0 ? void 0 : _c.magicLink) === null || _d === void 0 ? void 0 : _d.defaultChainId;
+        if (!apiKey) {
+            throw new Error('Missing MagicLink configuration. Add your MagicLink API key to your project configuration via the Dynamic Labs dashboard.');
+        }
         this._magicClient = new MagicClientNetworkHandler({
-            config,
             createClient: (config) => new Magic(apiKey, config),
-            evmNetworks,
+            defaultChainId,
+            evmNetworks: opts.evmNetworks,
         });
-        this.evmNetworks = evmNetworks;
-        this._walletUiUtils = walletUiUtils;
+        this.evmNetworks = parseEvmNetworks(opts.evmNetworks);
+        this._walletUiUtils = opts.walletUiUtils;
     }
     getDeepLink() {
         return undefined;

package/src/wallets/ethereum/coinbase.cjs

@@ -7,13 +7,13 @@ var ethProviderHelper = require('./ethProviderHelper.cjs');
 var EthWalletConnector = require('./EthWalletConnector.cjs');
 
 class Coinbase extends EthWalletConnector.EthWalletConnector {
-    constructor({ appName, appLogoUrl, evmNetworks, }) {
-        super({ evmNetworks });
+    constructor(_a) {
+        var { appName, appLogoUrl, evmNetworks } = _a, props = tslib.__rest(_a, ["appName", "appLogoUrl", "evmNetworks"]);
+        super(Object.assign({ evmNetworks }, props));
         this.name = 'Coinbase';
         this.supportedChains = ['EVM', 'ETH'];
         this.connectedChain = 'EVM';
         this.canConnectViaQrCode = true;
-        this.ethProviderHelper = new ethProviderHelper.EthProviderHelper();
         this.coinbaseProviderOpts = {
             appLogoUrl: appLogoUrl,
             appName: appName,
@@ -21,26 +21,24 @@ class Coinbase extends EthWalletConnector.EthWalletConnector {
         };
     }
     setupEventListeners(listeners) {
-        return this.ethProviderHelper._setupEventListeners(listeners, this.getWeb3Provider());
-    }
-    teardownEventListeners() {
-        return this.ethProviderHelper._teardownEventListeners(this.name);
+        const { tearDownEventListeners } = ethProviderHelper.EthProviderHelper._setupEventListeners(this.name, listeners, this.getWeb3Provider());
+        this.teardownEventListeners = tearDownEventListeners;
     }
     getWeb3Provider() {
         if (this.isInstalledOnBrowser()) {
-            return this.ethProviderHelper.findProvider(this.name);
+            return ethProviderHelper.EthProviderHelper.findProvider(this.name);
         }
         return new ethers.ethers.providers.Web3Provider(coinbase.getCoinbaseProvider({
             opts: this.coinbaseProviderOpts,
         }), 'any');
     }
     isInstalledOnBrowser() {
-        return this.ethProviderHelper.isInstalledHelper(this.name);
+        return ethProviderHelper.EthProviderHelper.isInstalledHelper(this.name);
     }
     fetchPublicAddress(opts) {
         return tslib.__awaiter(this, void 0, void 0, function* () {
             if (this.isInstalledOnBrowser()) {
-                return this.ethProviderHelper.fetchPublicAddressWithName(this.name);
+                return ethProviderHelper.EthProviderHelper.fetchPublicAddressWithName(this.name);
             }
             return coinbase.fetchPublicAddress(this.coinbaseProviderOpts, opts);
         });
@@ -48,7 +46,7 @@ class Coinbase extends EthWalletConnector.EthWalletConnector {
     signMessage(messageToSign) {
         return tslib.__awaiter(this, void 0, void 0, function* () {
             if (this.isInstalledOnBrowser()) {
-                return this.ethProviderHelper.signMessageWithName(messageToSign, this.name);
+                return ethProviderHelper.EthProviderHelper.signMessageWithName(messageToSign, this.name);
             }
             return coinbase.signMessage(this.coinbaseProviderOpts, messageToSign);
         });

package/src/wallets/ethereum/coinbase.d.ts

@@ -1,22 +1,18 @@
 import { ethers } from 'ethers';
 import { Chain, FetchPublicAddressOpts, WalletEventListeners } from '@dynamic-labs/wallet-connector-core';
-import { EthProviderHelper } from './ethProviderHelper';
-import { EthWalletConnector } from './EthWalletConnector';
-import { EvmNetwork } from './evm-network';
+import { EthWalletConnector, EthWalletConnectorOpts } from './EthWalletConnector';
+type CoinbaseOpts = EthWalletConnectorOpts & {
+    appLogoUrl?: string;
+    appName?: string;
+};
 declare class Coinbase extends EthWalletConnector {
     name: string;
     supportedChains: Chain[];
     connectedChain: Chain;
     canConnectViaQrCode: boolean;
-    ethProviderHelper: EthProviderHelper;
     private coinbaseProviderOpts;
-    constructor({ appName, appLogoUrl, evmNetworks, }: {
-        appLogoUrl?: string;
-        appName?: string;
-        evmNetworks: EvmNetwork[];
-    });
-    setupEventListeners(listeners: WalletEventListeners): () => void;
-    teardownEventListeners(): void;
+    constructor({ appName, appLogoUrl, evmNetworks, ...props }: CoinbaseOpts);
+    setupEventListeners(listeners: WalletEventListeners): void;
     getWeb3Provider(): ethers.providers.Web3Provider | undefined;
     isInstalledOnBrowser(): boolean;
     fetchPublicAddress(opts?: FetchPublicAddressOpts): Promise<string | undefined>;

package/src/wallets/ethereum/coinbase.js

@@ -1,17 +1,17 @@
-import { __awaiter } from 'tslib';
+import { __rest, __awaiter } from 'tslib';
 import { ethers } from 'ethers';
 import { getCoinbaseProvider, fetchPublicAddress, signMessage, killCoinbaseSession } from '../clients/coinbase/coinbase.js';
 import { EthProviderHelper } from './ethProviderHelper.js';
 import { EthWalletConnector } from './EthWalletConnector.js';
 
 class Coinbase extends EthWalletConnector {
-    constructor({ appName, appLogoUrl, evmNetworks, }) {
-        super({ evmNetworks });
+    constructor(_a) {
+        var { appName, appLogoUrl, evmNetworks } = _a, props = __rest(_a, ["appName", "appLogoUrl", "evmNetworks"]);
+        super(Object.assign({ evmNetworks }, props));
         this.name = 'Coinbase';
         this.supportedChains = ['EVM', 'ETH'];
         this.connectedChain = 'EVM';
         this.canConnectViaQrCode = true;
-        this.ethProviderHelper = new EthProviderHelper();
         this.coinbaseProviderOpts = {
             appLogoUrl: appLogoUrl,
             appName: appName,
@@ -19,26 +19,24 @@ class Coinbase extends EthWalletConnector {
         };
     }
     setupEventListeners(listeners) {
-        return this.ethProviderHelper._setupEventListeners(listeners, this.getWeb3Provider());
-    }
-    teardownEventListeners() {
-        return this.ethProviderHelper._teardownEventListeners(this.name);
+        const { tearDownEventListeners } = EthProviderHelper._setupEventListeners(this.name, listeners, this.getWeb3Provider());
+        this.teardownEventListeners = tearDownEventListeners;
     }
     getWeb3Provider() {
         if (this.isInstalledOnBrowser()) {
-            return this.ethProviderHelper.findProvider(this.name);
+            return EthProviderHelper.findProvider(this.name);
         }
         return new ethers.providers.Web3Provider(getCoinbaseProvider({
             opts: this.coinbaseProviderOpts,
         }), 'any');
     }
     isInstalledOnBrowser() {
-        return this.ethProviderHelper.isInstalledHelper(this.name);
+        return EthProviderHelper.isInstalledHelper(this.name);
     }
     fetchPublicAddress(opts) {
         return __awaiter(this, void 0, void 0, function* () {
             if (this.isInstalledOnBrowser()) {
-                return this.ethProviderHelper.fetchPublicAddressWithName(this.name);
+                return EthProviderHelper.fetchPublicAddressWithName(this.name);
             }
             return fetchPublicAddress(this.coinbaseProviderOpts, opts);
         });
@@ -46,7 +44,7 @@ class Coinbase extends EthWalletConnector {
     signMessage(messageToSign) {
         return __awaiter(this, void 0, void 0, function* () {
             if (this.isInstalledOnBrowser()) {
-                return this.ethProviderHelper.signMessageWithName(messageToSign, this.name);
+                return EthProviderHelper.signMessageWithName(messageToSign, this.name);
             }
             return signMessage(this.coinbaseProviderOpts, messageToSign);
         });

package/src/wallets/ethereum/ethProviderHelper.cjs

@@ -4,70 +4,19 @@ Object.defineProperty(exports, '__esModule', { value: true });
 
 var tslib = require('tslib');
 var ethers = require('ethers');
+var walletConnectorCore = require('@dynamic-labs/wallet-connector-core');
 var normalizeWalletName = require('../../utils/normalizeWalletName/normalizeWalletName.cjs');
 var ProviderLookup = require('../ProviderLookup.cjs');
 var isUnsupportedProviderError = require('../../utils/isUnsupportedProviderError/isUnsupportedProviderError.cjs');
-var logger = require('../../utils/logger.cjs');
 
+var _a;
 class EthProviderHelper {
-    constructor() {
-        this.MetamaskProvider = () => 
-        // Stop these wallets from showing up as MetaMask
-        this.installedProviderLookup([
-            { flag: 'isDawn', value: false },
-            { flag: 'isBraveWallet', value: false },
-            { flag: 'isTrustWallet', value: false },
-            { flag: 'isExodus', value: false },
-            { flag: 'isPhantom', value: false },
-            { flag: 'isZerion', value: false },
-            { flag: 'isMetaMask', value: true },
-        ]);
-        this.BraveProvider = () => this.installedProviderLookup([{ flag: 'isBraveWallet', value: true }]);
-        this.DawnProvider = () => this.installedProviderLookup([{ flag: 'isDawn', value: true }]);
-        this.FrameProvider = () => this.installedProviderLookup([{ flag: 'isFrame', value: true }]);
-        this.CoinbaseProvider = () => this.installedProviderLookup([{ flag: 'isCoinbaseWallet', value: true }]);
-        this.OperaProvider = () => this.installedProviderLookup([{ flag: 'isOpera', value: true }]);
-        this.GameStopProvider = () => this.installedProviderLookup([{ flag: 'isGamestop', value: true }]);
-        this.ExodusProvider = () => this.installedProviderLookup([{ flag: 'isExodus', value: true }]);
-        this.BloctoProvider = () => this.installedProviderLookup([{ flag: 'isBlocto', value: true }]);
-        this.TrustWalletProvider = () => this.installedProviderLookup([{ flag: 'isTrustWallet', value: true }]);
-        this.PhantomProvider = () => this.installedProviderLookup([{ flag: 'isPhantom', value: true }]);
-        this.ZerionProvider = () => this.installedProviderLookup([{ flag: 'isZerion', value: true }]);
-        this.UnknownInjectedProvider = () => this.installedProviderLookup([
-            { flag: 'isMetaMask', value: false },
-            { flag: 'isExodus', value: false },
-            { flag: 'isCoinbaseWallet', value: false },
-            { flag: 'isBraveWallet', value: false },
-            { flag: 'isGamestop', value: false },
-            { flag: 'isFrame', value: false },
-            { flag: 'isOpera', value: false },
-            { flag: 'isBlocto', value: false },
-            { flag: 'isTrustWallet', value: false },
-            { flag: 'isPhantom', value: false },
-            { flag: 'isZerion', value: false },
-        ]);
-        this.providers = {
-            bloctoinjected: this.BloctoProvider,
-            braveevm: this.BraveProvider,
-            coinbase: this.CoinbaseProvider,
-            dawn: this.DawnProvider,
-            exodusevm: this.ExodusProvider,
-            frame: this.FrameProvider,
-            gamestop: this.GameStopProvider,
-            injectedwallet: this.UnknownInjectedProvider,
-            metamask: this.MetamaskProvider,
-            opera: this.OperaProvider,
-            phantomevm: this.PhantomProvider,
-            trust: this.TrustWalletProvider,
-            zerion: this.ZerionProvider,
-        };
-    }
-    installedProviderLookup(providerFlags) {
+    static installedProviderLookup(providerFlags) {
         const allInstalledProviders = this.allInstalledProviders();
         return ProviderLookup.ProviderLookup(allInstalledProviders, providerFlags);
     }
-    allInstalledProviders() {
-        var _a;
+    static allInstalledProviders() {
+        var _b;
         const ethereumProviders = [];
         if (window.ethereum) {
             if (!window.ethereum.providers) {
@@ -79,7 +28,7 @@ class EthProviderHelper {
                 });
             }
         }
-        if ((_a = window.phantom) === null || _a === void 0 ? void 0 : _a.ethereum) {
+        if ((_b = window.phantom) === null || _b === void 0 ? void 0 : _b.ethereum) {
             ethereumProviders.push(window.phantom.ethereum);
         }
         if (window.zerionWallet) {
@@ -87,27 +36,27 @@ class EthProviderHelper {
         }
         return ethereumProviders;
     }
-    isInstalledHelper(walletName) {
+    static isInstalledHelper(walletName) {
         return this.findProvider(walletName) !== undefined;
     }
-    findProvider(walletName) {
-        var _a, _b;
+    static findProvider(walletName) {
+        var _b, _c;
         try {
-            const provider = (_b = (_a = this.providers)[normalizeWalletName.normalizeWalletName(walletName)]) === null || _b === void 0 ? void 0 : _b.call(_a);
+            const provider = (_c = (_b = this.providers)[normalizeWalletName.normalizeWalletName(walletName)]) === null || _c === void 0 ? void 0 : _c.call(_b);
             return provider === undefined
                 ? undefined
                 : new ethers.ethers.providers.Web3Provider(provider, 'any'); // https://github.com/ethers-io/ethers.js/discussions/1480
         }
         catch (err) {
             if (isUnsupportedProviderError.isUnsupportedProviderError(err)) {
-                logger.logger.error(`ETH Provider is not supported ${err.value}`, err);
+                walletConnectorCore.logger.error(`ETH Provider is not supported ${err.value}`, err);
                 return;
             }
-            logger.logger.error(`Could not find provider for ${walletName}`, err);
+            walletConnectorCore.logger.error(`Could not find provider for ${walletName}`, err);
             return undefined;
         }
     }
-    fetchPublicAddressWithName(name) {
+    static fetchPublicAddressWithName(name) {
         return tslib.__awaiter(this, void 0, void 0, function* () {
             const provider = this.findProvider(name);
             if (!provider) {
@@ -116,7 +65,7 @@ class EthProviderHelper {
             return this.fetchPublicAddressWithProvider(provider);
         });
     }
-    fetchPublicAddressWithProvider(provider) {
+    static fetchPublicAddressWithProvider(provider) {
         return tslib.__awaiter(this, void 0, void 0, function* () {
             try {
                 const [lowercaseAddress] = yield provider.send('eth_requestAccounts', []);
@@ -124,12 +73,12 @@ class EthProviderHelper {
                 return publicAddress;
             }
             catch (err) {
-                logger.logger.error(err);
+                walletConnectorCore.logger.error(err);
                 return Promise.reject(err);
             }
         });
     }
-    signMessageWithName(messageToSign, name) {
+    static signMessageWithName(messageToSign, name) {
         return tslib.__awaiter(this, void 0, void 0, function* () {
             const walletAddress = yield this.fetchPublicAddressWithName(name);
             if (!walletAddress) {
@@ -144,54 +93,107 @@ class EthProviderHelper {
             return signedMessage;
         });
     }
-    _setupEventListeners(listeners, web3Provider) {
+    static _setupEventListeners(name, listeners, web3Provider) {
         if (!web3Provider) {
-            return () => {
-                // nothing to teardown
+            return {
+                tearDownEventListeners: () => { },
             };
         }
         const externalProvider = web3Provider.provider;
-        this.handleAccountChange = (accounts) => tslib.__awaiter(this, void 0, void 0, function* () {
-            var _a, _b;
+        const handleAccountChange = (accounts) => tslib.__awaiter(this, void 0, void 0, function* () {
+            var _b, _c;
             if (accounts.length === 0) {
-                yield ((_a = listeners.onDisconnect) === null || _a === void 0 ? void 0 : _a.call(listeners));
+                yield ((_b = listeners.onDisconnect) === null || _b === void 0 ? void 0 : _b.call(listeners));
                 return;
             }
-            yield ((_b = listeners.onAccountChange) === null || _b === void 0 ? void 0 : _b.call(listeners, accounts));
+            yield ((_c = listeners.onAccountChange) === null || _c === void 0 ? void 0 : _c.call(listeners, accounts));
         });
-        this.handleChainChange = () => tslib.__awaiter(this, void 0, void 0, function* () {
-            var _c;
+        const handleChainChange = () => tslib.__awaiter(this, void 0, void 0, function* () {
+            var _d;
             const network = yield web3Provider.getNetwork();
-            yield ((_c = listeners.onChainChange) === null || _c === void 0 ? void 0 : _c.call(listeners, network.chainId.toString()));
+            yield ((_d = listeners.onChainChange) === null || _d === void 0 ? void 0 : _d.call(listeners, network.chainId.toString()));
         });
-        this.handleDisconnect = (error) => tslib.__awaiter(this, void 0, void 0, function* () {
-            var _d;
+        const handleDisconnect = (error) => tslib.__awaiter(this, void 0, void 0, function* () {
+            var _e;
             if ((error === null || error === void 0 ? void 0 : error.code) === 1013) {
                 return;
             }
-            yield ((_d = listeners.onDisconnect) === null || _d === void 0 ? void 0 : _d.call(listeners));
+            yield ((_e = listeners.onDisconnect) === null || _e === void 0 ? void 0 : _e.call(listeners));
         });
-        externalProvider.on('accountsChanged', this.handleAccountChange);
-        externalProvider.on('chainChanged', this.handleChainChange);
-        externalProvider.on('disconnect', this.handleDisconnect);
-        return () => { };
-    }
-    _teardownEventListeners(name) {
-        const web3Provider = this.findProvider(name);
-        if (!web3Provider || !(web3Provider === null || web3Provider === void 0 ? void 0 : web3Provider.provider)) {
-            return;
-        }
-        const externalProvider = web3Provider.provider;
-        if (this.handleAccountChange) {
-            externalProvider.removeListener('accountsChanged', this.handleAccountChange);
-        }
-        if (this.handleChainChange) {
-            externalProvider.removeListener('chainChanged', this.handleChainChange);
-        }
-        if (this.handleDisconnect) {
-            externalProvider.removeListener('disconnect', this.handleDisconnect);
-        }
+        externalProvider.on('accountsChanged', handleAccountChange);
+        externalProvider.on('chainChanged', handleChainChange);
+        externalProvider.on('disconnect', handleDisconnect);
+        const tearDownEventListeners = () => {
+            const web3Provider = this.findProvider(name);
+            if (!web3Provider || !(web3Provider === null || web3Provider === void 0 ? void 0 : web3Provider.provider)) {
+                return;
+            }
+            const externalProvider = web3Provider.provider;
+            if (handleAccountChange) {
+                externalProvider.removeListener('accountsChanged', handleAccountChange);
+            }
+            if (handleChainChange) {
+                externalProvider.removeListener('chainChanged', handleChainChange);
+            }
+            if (handleDisconnect) {
+                externalProvider.removeListener('disconnect', handleDisconnect);
+            }
+        };
+        return {
+            tearDownEventListeners,
+        };
     }
-}
+}
+_a = EthProviderHelper;
+EthProviderHelper.MetamaskProvider = () => 
+// Stop these wallets from showing up as MetaMask
+_a.installedProviderLookup([
+    { flag: 'isDawn', value: false },
+    { flag: 'isBraveWallet', value: false },
+    { flag: 'isTrustWallet', value: false },
+    { flag: 'isExodus', value: false },
+    { flag: 'isPhantom', value: false },
+    { flag: 'isZerion', value: false },
+    { flag: 'isMetaMask', value: true },
+]);
+EthProviderHelper.BraveProvider = () => _a.installedProviderLookup([{ flag: 'isBraveWallet', value: true }]);
+EthProviderHelper.DawnProvider = () => _a.installedProviderLookup([{ flag: 'isDawn', value: true }]);
+EthProviderHelper.FrameProvider = () => _a.installedProviderLookup([{ flag: 'isFrame', value: true }]);
+EthProviderHelper.CoinbaseProvider = () => _a.installedProviderLookup([{ flag: 'isCoinbaseWallet', value: true }]);
+EthProviderHelper.OperaProvider = () => _a.installedProviderLookup([{ flag: 'isOpera', value: true }]);
+EthProviderHelper.GameStopProvider = () => _a.installedProviderLookup([{ flag: 'isGamestop', value: true }]);
+EthProviderHelper.ExodusProvider = () => _a.installedProviderLookup([{ flag: 'isExodus', value: true }]);
+EthProviderHelper.BloctoProvider = () => _a.installedProviderLookup([{ flag: 'isBlocto', value: true }]);
+EthProviderHelper.TrustWalletProvider = () => _a.installedProviderLookup([{ flag: 'isTrustWallet', value: true }]);
+EthProviderHelper.PhantomProvider = () => _a.installedProviderLookup([{ flag: 'isPhantom', value: true }]);
+EthProviderHelper.ZerionProvider = () => _a.installedProviderLookup([{ flag: 'isZerion', value: true }]);
+EthProviderHelper.UnknownInjectedProvider = () => _a.installedProviderLookup([
+    { flag: 'isMetaMask', value: false },
+    { flag: 'isExodus', value: false },
+    { flag: 'isCoinbaseWallet', value: false },
+    { flag: 'isBraveWallet', value: false },
+    { flag: 'isGamestop', value: false },
+    { flag: 'isFrame', value: false },
+    { flag: 'isOpera', value: false },
+    { flag: 'isBlocto', value: false },
+    { flag: 'isTrustWallet', value: false },
+    { flag: 'isPhantom', value: false },
+    { flag: 'isZerion', value: false },
+]);
+EthProviderHelper.providers = {
+    bloctoinjected: _a.BloctoProvider,
+    braveevm: _a.BraveProvider,
+    coinbase: _a.CoinbaseProvider,
+    dawn: _a.DawnProvider,
+    exodusevm: _a.ExodusProvider,
+    frame: _a.FrameProvider,
+    gamestop: _a.GameStopProvider,
+    injectedwallet: _a.UnknownInjectedProvider,
+    metamask: _a.MetamaskProvider,
+    opera: _a.OperaProvider,
+    phantomevm: _a.PhantomProvider,
+    trust: _a.TrustWalletProvider,
+    zerion: _a.ZerionProvider,
+};
 
 exports.EthProviderHelper = EthProviderHelper;

package/src/wallets/ethereum/ethProviderHelper.d.ts

@@ -2,39 +2,32 @@ import { ethers } from 'ethers';
 import { WalletEventListeners } from '@dynamic-labs/wallet-connector-core';
 import { ProviderCondition, IEthereum } from '../window';
 type Provider = () => ethers.providers.ExternalProvider | undefined;
-type AccountChangeEventHandler = (accounts: string[]) => Promise<void>;
-type ChainChangeEventHandler = (chainId: string | number) => Promise<void>;
-type DisconnectEventHandler = (error?: {
-    code: number;
-}) => Promise<void>;
 export declare class EthProviderHelper {
-    handleAccountChange: AccountChangeEventHandler | undefined;
-    handleChainChange: ChainChangeEventHandler | undefined;
-    handleDisconnect: DisconnectEventHandler | undefined;
-    MetamaskProvider: Provider;
-    BraveProvider: Provider;
-    DawnProvider: Provider;
-    FrameProvider: Provider;
-    CoinbaseProvider: Provider;
-    OperaProvider: Provider;
-    GameStopProvider: Provider;
-    ExodusProvider: Provider;
-    BloctoProvider: Provider;
-    TrustWalletProvider: Provider;
-    PhantomProvider: Provider;
-    ZerionProvider: Provider;
-    UnknownInjectedProvider: Provider;
-    providers: {
+    static MetamaskProvider: Provider;
+    static BraveProvider: Provider;
+    static DawnProvider: Provider;
+    static FrameProvider: Provider;
+    static CoinbaseProvider: Provider;
+    static OperaProvider: Provider;
+    static GameStopProvider: Provider;
+    static ExodusProvider: Provider;
+    static BloctoProvider: Provider;
+    static TrustWalletProvider: Provider;
+    static PhantomProvider: Provider;
+    static ZerionProvider: Provider;
+    static UnknownInjectedProvider: Provider;
+    static providers: {
         [wallet: string]: Provider;
     };
-    installedProviderLookup(providerFlags: Array<ProviderCondition>): IEthereum | undefined;
-    allInstalledProviders(): IEthereum[];
-    isInstalledHelper(walletName: string): boolean;
-    findProvider(walletName: string): ethers.providers.Web3Provider | undefined;
-    fetchPublicAddressWithName(name: string): Promise<string | undefined>;
-    fetchPublicAddressWithProvider(provider: ethers.providers.Web3Provider): Promise<string | undefined>;
-    signMessageWithName(messageToSign: string, name: string): Promise<string | undefined>;
-    _setupEventListeners(listeners: WalletEventListeners, web3Provider?: ethers.providers.Web3Provider): () => void;
-    _teardownEventListeners(name: string): void;
+    static installedProviderLookup(providerFlags: Array<ProviderCondition>): IEthereum | undefined;
+    static allInstalledProviders(): IEthereum[];
+    static isInstalledHelper(walletName: string): boolean;
+    static findProvider(walletName: string): ethers.providers.Web3Provider | undefined;
+    static fetchPublicAddressWithName(name: string): Promise<string | undefined>;
+    static fetchPublicAddressWithProvider(provider: ethers.providers.Web3Provider): Promise<string | undefined>;
+    static signMessageWithName(messageToSign: string, name: string): Promise<string | undefined>;
+    static _setupEventListeners(name: string, listeners: WalletEventListeners, web3Provider?: ethers.providers.Web3Provider): {
+        tearDownEventListeners: () => void;
+    };
 }
 export {};