@dynamic-labs/ethereum 0.0.0-exp20240808.0

package/src/ethProviderHelper.cjs

@@ -0,0 +1,163 @@
+'use client'
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var _tslib = require('../_virtual/_tslib.cjs');
+var viem = require('viem');
+var walletConnectorCore = require('@dynamic-labs/wallet-connector-core');
+var utils = require('@dynamic-labs/utils');
+var viemUtils = require('@dynamic-labs/viem-utils');
+
+class EthProviderHelper {
+    constructor(wallet, connector) {
+        this.wallet = wallet;
+        this.connector = connector;
+    }
+    getInstalledProvider() {
+        const eip6963Config = this.getEip6963Config();
+        if (eip6963Config) {
+            const eip6963Provider = this.eip6963ProviderLookup(eip6963Config.rdns);
+            if (eip6963Provider) {
+                return eip6963Provider;
+            }
+        }
+        const config = this.getInjectedConfig();
+        if (!config ||
+            !config.extensionLocators ||
+            !config.extensionLocators.length)
+            return undefined;
+        return this.installedProviderLookup(config.extensionLocators);
+    }
+    getEip6963Config() {
+        if (!this.wallet || !this.wallet.eip6963Config)
+            return;
+        return this.wallet.eip6963Config;
+    }
+    getInjectedConfig() {
+        if (!this.wallet || !this.wallet.injectedConfig)
+            return;
+        const { injectedConfig } = this.wallet;
+        return injectedConfig.find((c) => c.chain === 'evm');
+    }
+    installedProviders() {
+        const config = this.getInjectedConfig();
+        if (!config)
+            return [];
+        const providers = [];
+        if (config.windowLocations) {
+            for (const windowLocation of config.windowLocations) {
+                const foundProviders = utils.getProvidersFromWindow(windowLocation);
+                if (foundProviders && foundProviders.length)
+                    providers.push(...foundProviders);
+            }
+        }
+        if (window.ethereum) {
+            if (!window.ethereum.providers || !window.ethereum.providers.length) {
+                providers.push(window.ethereum);
+            }
+            else {
+                window.ethereum.providers.forEach((p) => providers.push(p));
+            }
+        }
+        return providers;
+    }
+    installedProviderLookup(extensionLocators) {
+        const allInstalledProviders = this.installedProviders();
+        return walletConnectorCore.ProviderLookup(allInstalledProviders, extensionLocators);
+    }
+    eip6963ProviderLookup(rdns) {
+        var _a;
+        const { providers } = utils.Eip6963ProviderSingleton.get();
+        return (_a = providers.find((provider) => { var _a; return ((_a = provider === null || provider === void 0 ? void 0 : provider.info) === null || _a === void 0 ? void 0 : _a.rdns) === rdns; })) === null || _a === void 0 ? void 0 : _a.provider;
+    }
+    isInstalledHelper() {
+        return this.findProvider() !== undefined;
+    }
+    findProvider() {
+        return this.getInstalledProvider();
+    }
+    findWalletClient(chainId) {
+        const provider = this.findProvider();
+        if (!provider) {
+            return undefined;
+        }
+        return viem.createWalletClient({
+            account: this.connector.getActiveAccount(),
+            chain: chainId ? viemUtils.chainsMap[chainId] : this.connector.getActiveChain(),
+            transport: viem.custom(provider),
+        });
+    }
+    getAddress() {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            const client = this.findWalletClient();
+            if (!client) {
+                return Promise.resolve(undefined);
+            }
+            return this.getAddressWithProvider(client);
+        });
+    }
+    getAddressWithProvider(client) {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            try {
+                const [lowercaseAddress] = yield client.requestAddresses();
+                const publicAddress = viem.getAddress(lowercaseAddress);
+                this.connector.setActiveAccount(publicAddress);
+                return publicAddress;
+            }
+            catch (err) {
+                walletConnectorCore.logger.error(err);
+                return Promise.reject(err);
+            }
+        });
+    }
+    signMessage(messageToSign) {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            const walletAddress = yield this.getAddress();
+            if (!walletAddress) {
+                return Promise.resolve(undefined);
+            }
+            const client = this.findWalletClient();
+            if (!client) {
+                return Promise.resolve(undefined);
+            }
+            const signedMessage = yield client.signMessage({
+                account: walletAddress,
+                message: messageToSign,
+            });
+            return signedMessage;
+        });
+    }
+    _setupEventListeners(walletConnector) {
+        const web3Provider = this.findProvider();
+        if (!web3Provider) {
+            return {
+                tearDownEventListeners: () => { },
+            };
+        }
+        const { handleAccountChange, handleChainChange, handleDisconnect } = walletConnectorCore.eventListenerHandlers(walletConnector);
+        web3Provider.on('accountsChanged', handleAccountChange);
+        web3Provider.on('chainChanged', handleChainChange);
+        web3Provider.on('disconnect', handleDisconnect);
+        const tearDownEventListeners = () => {
+            const web3Provider = this.findProvider();
+            if (!web3Provider) {
+                return;
+            }
+            if (handleAccountChange) {
+                web3Provider.removeListener('accountsChanged', handleAccountChange);
+            }
+            if (handleChainChange) {
+                web3Provider.removeListener('chainChanged', handleChainChange);
+            }
+            if (handleDisconnect) {
+                web3Provider.removeListener('disconnect', handleDisconnect);
+            }
+        };
+        return {
+            tearDownEventListeners,
+        };
+    }
+}
+
+exports.EthProviderHelper = EthProviderHelper;

package/src/ethProviderHelper.d.ts

@@ -0,0 +1,43 @@
+import { Hex, WalletClient, Account, Transport, Chain as ViemChain } from 'viem';
+import { ProviderCondition, WalletConnector } from '@dynamic-labs/wallet-connector-core';
+import { WalletSchema } from '@dynamic-labs/wallet-book';
+import { IEthereum, ExtensionLocator } from './types';
+import { EthWalletConnector } from '.';
+export declare class EthProviderHelper {
+    private wallet;
+    private connector;
+    constructor(wallet: WalletSchema, connector: EthWalletConnector);
+    getInstalledProvider(): IEthereum | undefined;
+    getEip6963Config(): {
+        rdns: string;
+    } | undefined;
+    getInjectedConfig(): {
+        chain: string;
+        extensionLocators: {
+            value: boolean;
+            flag: string;
+        }[];
+        providerInterface?: string | undefined;
+        walletStandard?: {
+            features: string[];
+            name: string;
+        } | undefined;
+        walletStandardLocators?: {
+            name: string;
+            locator: string;
+        }[] | undefined;
+        windowLocations?: string[] | undefined;
+    } | undefined;
+    installedProviders(): IEthereum[];
+    installedProviderLookup(extensionLocators: Array<ProviderCondition<ExtensionLocator>>): IEthereum | undefined;
+    eip6963ProviderLookup(rdns: string): IEthereum | undefined;
+    isInstalledHelper(): boolean;
+    findProvider(): IEthereum | undefined;
+    findWalletClient(chainId?: string): WalletClient<Transport, ViemChain, Account> | undefined;
+    getAddress(): Promise<Hex | undefined>;
+    getAddressWithProvider(client: WalletClient): Promise<Hex | undefined>;
+    signMessage(messageToSign: string): Promise<string | undefined>;
+    _setupEventListeners(walletConnector: WalletConnector): {
+        tearDownEventListeners: () => void;
+    };
+}

package/src/ethProviderHelper.js

@@ -0,0 +1,159 @@
+'use client'
+import { __awaiter } from '../_virtual/_tslib.js';
+import { createWalletClient, custom, getAddress } from 'viem';
+import { ProviderLookup, eventListenerHandlers, logger } from '@dynamic-labs/wallet-connector-core';
+import { getProvidersFromWindow, Eip6963ProviderSingleton } from '@dynamic-labs/utils';
+import { chainsMap } from '@dynamic-labs/viem-utils';
+
+class EthProviderHelper {
+    constructor(wallet, connector) {
+        this.wallet = wallet;
+        this.connector = connector;
+    }
+    getInstalledProvider() {
+        const eip6963Config = this.getEip6963Config();
+        if (eip6963Config) {
+            const eip6963Provider = this.eip6963ProviderLookup(eip6963Config.rdns);
+            if (eip6963Provider) {
+                return eip6963Provider;
+            }
+        }
+        const config = this.getInjectedConfig();
+        if (!config ||
+            !config.extensionLocators ||
+            !config.extensionLocators.length)
+            return undefined;
+        return this.installedProviderLookup(config.extensionLocators);
+    }
+    getEip6963Config() {
+        if (!this.wallet || !this.wallet.eip6963Config)
+            return;
+        return this.wallet.eip6963Config;
+    }
+    getInjectedConfig() {
+        if (!this.wallet || !this.wallet.injectedConfig)
+            return;
+        const { injectedConfig } = this.wallet;
+        return injectedConfig.find((c) => c.chain === 'evm');
+    }
+    installedProviders() {
+        const config = this.getInjectedConfig();
+        if (!config)
+            return [];
+        const providers = [];
+        if (config.windowLocations) {
+            for (const windowLocation of config.windowLocations) {
+                const foundProviders = getProvidersFromWindow(windowLocation);
+                if (foundProviders && foundProviders.length)
+                    providers.push(...foundProviders);
+            }
+        }
+        if (window.ethereum) {
+            if (!window.ethereum.providers || !window.ethereum.providers.length) {
+                providers.push(window.ethereum);
+            }
+            else {
+                window.ethereum.providers.forEach((p) => providers.push(p));
+            }
+        }
+        return providers;
+    }
+    installedProviderLookup(extensionLocators) {
+        const allInstalledProviders = this.installedProviders();
+        return ProviderLookup(allInstalledProviders, extensionLocators);
+    }
+    eip6963ProviderLookup(rdns) {
+        var _a;
+        const { providers } = Eip6963ProviderSingleton.get();
+        return (_a = providers.find((provider) => { var _a; return ((_a = provider === null || provider === void 0 ? void 0 : provider.info) === null || _a === void 0 ? void 0 : _a.rdns) === rdns; })) === null || _a === void 0 ? void 0 : _a.provider;
+    }
+    isInstalledHelper() {
+        return this.findProvider() !== undefined;
+    }
+    findProvider() {
+        return this.getInstalledProvider();
+    }
+    findWalletClient(chainId) {
+        const provider = this.findProvider();
+        if (!provider) {
+            return undefined;
+        }
+        return createWalletClient({
+            account: this.connector.getActiveAccount(),
+            chain: chainId ? chainsMap[chainId] : this.connector.getActiveChain(),
+            transport: custom(provider),
+        });
+    }
+    getAddress() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const client = this.findWalletClient();
+            if (!client) {
+                return Promise.resolve(undefined);
+            }
+            return this.getAddressWithProvider(client);
+        });
+    }
+    getAddressWithProvider(client) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const [lowercaseAddress] = yield client.requestAddresses();
+                const publicAddress = getAddress(lowercaseAddress);
+                this.connector.setActiveAccount(publicAddress);
+                return publicAddress;
+            }
+            catch (err) {
+                logger.error(err);
+                return Promise.reject(err);
+            }
+        });
+    }
+    signMessage(messageToSign) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const walletAddress = yield this.getAddress();
+            if (!walletAddress) {
+                return Promise.resolve(undefined);
+            }
+            const client = this.findWalletClient();
+            if (!client) {
+                return Promise.resolve(undefined);
+            }
+            const signedMessage = yield client.signMessage({
+                account: walletAddress,
+                message: messageToSign,
+            });
+            return signedMessage;
+        });
+    }
+    _setupEventListeners(walletConnector) {
+        const web3Provider = this.findProvider();
+        if (!web3Provider) {
+            return {
+                tearDownEventListeners: () => { },
+            };
+        }
+        const { handleAccountChange, handleChainChange, handleDisconnect } = eventListenerHandlers(walletConnector);
+        web3Provider.on('accountsChanged', handleAccountChange);
+        web3Provider.on('chainChanged', handleChainChange);
+        web3Provider.on('disconnect', handleDisconnect);
+        const tearDownEventListeners = () => {
+            const web3Provider = this.findProvider();
+            if (!web3Provider) {
+                return;
+            }
+            if (handleAccountChange) {
+                web3Provider.removeListener('accountsChanged', handleAccountChange);
+            }
+            if (handleChainChange) {
+                web3Provider.removeListener('chainChanged', handleChainChange);
+            }
+            if (handleDisconnect) {
+                web3Provider.removeListener('disconnect', handleDisconnect);
+            }
+        };
+        return {
+            tearDownEventListeners,
+        };
+    }
+}
+
+export { EthProviderHelper };

package/src/index.cjs

@@ -0,0 +1,49 @@
+'use client'
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+require('./polyfills.cjs');
+var embeddedWalletEvm = require('@dynamic-labs/embedded-wallet-evm');
+var PhantomEvm = require('./injected/PhantomEvm.cjs');
+var ExodusEvm = require('./injected/ExodusEvm.cjs');
+var UnknownInjected = require('./injected/UnknownInjected.cjs');
+var FallbackEvmConnector = require('./injected/FallbackEvmConnector.cjs');
+var fetchInjectedWalletConnectors = require('./injected/fetchInjectedWalletConnectors.cjs');
+require('./walletConnect/walletConnect.cjs');
+var fetchWalletConnectWallets = require('./walletConnect/fetchWalletConnectWallets.cjs');
+var coinbase = require('./coinbase/coinbase.cjs');
+require('@dynamic-labs/rpc-provider-ethereum');
+var EthWalletConnector = require('./EthWalletConnector.cjs');
+var ethProviderHelper = require('./ethProviderHelper.cjs');
+var constants = require('./constants.cjs');
+var isEthWalletConnector = require('./utils/isEthWalletConnector/isEthWalletConnector.cjs');
+var getNameservice = require('./utils/getNameservice.cjs');
+var EthereumWallet = require('./wallet/EthereumWallet.cjs');
+var isEthereumWallet = require('./wallet/isEthereumWallet.cjs');
+
+const EthereumWalletConnectors = (props) => [
+    ...fetchInjectedWalletConnectors.injectedWalletOverrides,
+    ...fetchInjectedWalletConnectors.fetchInjectedWalletConnector(props),
+    ...fetchWalletConnectWallets.fetchWalletConnectWallets(props),
+    ...embeddedWalletEvm.TurnkeyEVMWalletConnectors(props),
+    coinbase.Coinbase,
+    UnknownInjected.UnknownInjected,
+    FallbackEvmConnector.FallbackEvmConnector,
+    fetchWalletConnectWallets.getWalletConnectConnector(),
+];
+
+exports.PhantomEvm = PhantomEvm.PhantomEvm;
+exports.ExodusEvm = ExodusEvm.ExodusEvm;
+exports.UnknownInjected = UnknownInjected.UnknownInjected;
+exports.FallbackEvmConnector = FallbackEvmConnector.FallbackEvmConnector;
+exports.fetchInjectedWalletConnector = fetchInjectedWalletConnectors.fetchInjectedWalletConnector;
+exports.injectedWalletOverrides = fetchInjectedWalletConnectors.injectedWalletOverrides;
+exports.EthWalletConnector = EthWalletConnector.EthWalletConnector;
+exports.EthProviderHelper = ethProviderHelper.EthProviderHelper;
+exports.INFURA_ID = constants.INFURA_ID;
+exports.isEthWalletConnector = isEthWalletConnector.isEthWalletConnector;
+exports.getNameservice = getNameservice.getNameservice;
+exports.EthereumWallet = EthereumWallet.EthereumWallet;
+exports.isEthereumWallet = isEthereumWallet.isEthereumWallet;
+exports.EthereumWalletConnectors = EthereumWalletConnectors;

package/src/index.d.ts

@@ -0,0 +1,11 @@
+import './polyfills';
+import { WalletConnectorConstructor } from '@dynamic-labs/wallet-connector-core';
+import '@dynamic-labs/rpc-provider-ethereum';
+export * from './injected';
+export * from './EthWalletConnector';
+export * from './ethProviderHelper';
+export * from './constants';
+export * from './types';
+export * from './utils';
+export * from './wallet';
+export declare const EthereumWalletConnectors: (props: any) => WalletConnectorConstructor[];

package/src/index.js

@@ -0,0 +1,35 @@
+'use client'
+import './polyfills.js';
+import { TurnkeyEVMWalletConnectors } from '@dynamic-labs/embedded-wallet-evm';
+export { PhantomEvm } from './injected/PhantomEvm.js';
+export { ExodusEvm } from './injected/ExodusEvm.js';
+import { UnknownInjected } from './injected/UnknownInjected.js';
+export { UnknownInjected } from './injected/UnknownInjected.js';
+import { FallbackEvmConnector } from './injected/FallbackEvmConnector.js';
+export { FallbackEvmConnector } from './injected/FallbackEvmConnector.js';
+import { injectedWalletOverrides, fetchInjectedWalletConnector } from './injected/fetchInjectedWalletConnectors.js';
+export { fetchInjectedWalletConnector, injectedWalletOverrides } from './injected/fetchInjectedWalletConnectors.js';
+import './walletConnect/walletConnect.js';
+import { fetchWalletConnectWallets, getWalletConnectConnector } from './walletConnect/fetchWalletConnectWallets.js';
+import { Coinbase } from './coinbase/coinbase.js';
+import '@dynamic-labs/rpc-provider-ethereum';
+export { EthWalletConnector } from './EthWalletConnector.js';
+export { EthProviderHelper } from './ethProviderHelper.js';
+export { INFURA_ID } from './constants.js';
+export { isEthWalletConnector } from './utils/isEthWalletConnector/isEthWalletConnector.js';
+export { getNameservice } from './utils/getNameservice.js';
+export { EthereumWallet } from './wallet/EthereumWallet.js';
+export { isEthereumWallet } from './wallet/isEthereumWallet.js';
+
+const EthereumWalletConnectors = (props) => [
+    ...injectedWalletOverrides,
+    ...fetchInjectedWalletConnector(props),
+    ...fetchWalletConnectWallets(props),
+    ...TurnkeyEVMWalletConnectors(props),
+    Coinbase,
+    UnknownInjected,
+    FallbackEvmConnector,
+    getWalletConnectConnector(),
+];
+
+export { EthereumWalletConnectors };

package/src/injected/ExodusEvm.cjs

@@ -0,0 +1,20 @@
+'use client'
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var walletBook = require('@dynamic-labs/wallet-book');
+var InjectedWalletBase = require('./InjectedWalletBase.cjs');
+
+// leaving ExodusEvm in here due to a backwards compatibility issue with this one wallet and v18
+class ExodusEvm extends InjectedWalletBase {
+    constructor(props) {
+        super(props);
+        this.name = 'ExodusEvm';
+        this.overrideKey = 'exodusevm';
+        this.walletConnectorFallback = true;
+        this.wallet = walletBook.findWalletBookWallet(this.walletBook, this.key);
+    }
+}
+
+exports.ExodusEvm = ExodusEvm;

package/src/injected/ExodusEvm.d.ts

@@ -0,0 +1,8 @@
+import { EthWalletConnectorOpts } from '..';
+import InjectedWalletBase from './InjectedWalletBase';
+export declare class ExodusEvm extends InjectedWalletBase {
+    name: string;
+    overrideKey: string;
+    walletConnectorFallback: boolean;
+    constructor(props: EthWalletConnectorOpts);
+}

package/src/injected/ExodusEvm.js

@@ -0,0 +1,16 @@
+'use client'
+import { findWalletBookWallet } from '@dynamic-labs/wallet-book';
+import InjectedWalletBase from './InjectedWalletBase.js';
+
+// leaving ExodusEvm in here due to a backwards compatibility issue with this one wallet and v18
+class ExodusEvm extends InjectedWalletBase {
+    constructor(props) {
+        super(props);
+        this.name = 'ExodusEvm';
+        this.overrideKey = 'exodusevm';
+        this.walletConnectorFallback = true;
+        this.wallet = findWalletBookWallet(this.walletBook, this.key);
+    }
+}
+
+export { ExodusEvm };

package/src/injected/FallbackEvmConnector.cjs

@@ -0,0 +1,22 @@
+'use client'
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var walletBook = require('@dynamic-labs/wallet-book');
+var InjectedWalletBase = require('./InjectedWalletBase.cjs');
+
+class FallbackEvmConnector extends InjectedWalletBase {
+    constructor(props) {
+        super(props);
+        this.name = 'Fallback Connector';
+        this.overrideKey = 'fallbackconnector';
+        this.isAvailable = false;
+        this.wallet = walletBook.findWalletBookWallet(this.walletBook, this.key);
+    }
+    isInstalledOnBrowser() {
+        return false;
+    }
+}
+
+exports.FallbackEvmConnector = FallbackEvmConnector;

package/src/injected/FallbackEvmConnector.d.ts

@@ -0,0 +1,9 @@
+import { EthWalletConnectorOpts } from '..';
+import InjectedWalletBase from './InjectedWalletBase';
+export declare class FallbackEvmConnector extends InjectedWalletBase {
+    name: string;
+    overrideKey: string;
+    isAvailable: boolean;
+    constructor(props: EthWalletConnectorOpts);
+    isInstalledOnBrowser(): boolean;
+}

package/src/injected/FallbackEvmConnector.js

@@ -0,0 +1,18 @@
+'use client'
+import { findWalletBookWallet } from '@dynamic-labs/wallet-book';
+import InjectedWalletBase from './InjectedWalletBase.js';
+
+class FallbackEvmConnector extends InjectedWalletBase {
+    constructor(props) {
+        super(props);
+        this.name = 'Fallback Connector';
+        this.overrideKey = 'fallbackconnector';
+        this.isAvailable = false;
+        this.wallet = findWalletBookWallet(this.walletBook, this.key);
+    }
+    isInstalledOnBrowser() {
+        return false;
+    }
+}
+
+export { FallbackEvmConnector };

package/src/injected/InjectedWalletBase.cjs

@@ -0,0 +1,110 @@
+'use client'
+'use strict';
+
+var _tslib = require('../../_virtual/_tslib.cjs');
+var walletBook = require('@dynamic-labs/wallet-book');
+var utils = require('@dynamic-labs/utils');
+var ethProviderHelper = require('../ethProviderHelper.cjs');
+var EthWalletConnector = require('../EthWalletConnector.cjs');
+var walletConnect = require('../walletConnect/walletConnect.cjs');
+
+class InjectedWalletBase extends EthWalletConnector.EthWalletConnector {
+    constructor() {
+        super(...arguments);
+        this.supportedChains = ['ETH', 'EVM'];
+        this.connectedChain = 'EVM';
+        this.walletConnectorFallback = false;
+    }
+    getEthProviderHelper() {
+        if (!this.wallet) {
+            // changing this to findWalletBookWallet so it returns undefined if not found which
+            // allows the getEthProviderHelper to return undefined if the wallet is not installed
+            this.wallet = walletBook.findWalletBookWallet(this.walletBook, this.key);
+        }
+        if (this.wallet && !this.ethProviderHelper) {
+            this.ethProviderHelper = new ethProviderHelper.EthProviderHelper(this.wallet, this);
+        }
+        // this.ethProviderHelper is undefined if the wallet is not installed or found in walletbook
+        return this.ethProviderHelper;
+    }
+    getMobileOrInstalledWallet() {
+        var _a, _b;
+        if (!this.wallet) {
+            this.wallet = walletBook.findWalletBookWallet(this.walletBook, this.key);
+        }
+        if (this.isInstalledOnBrowser()) {
+            return this;
+        }
+        // this is to handle the case where the user is in a webview.
+        // when the user is in a webview, customers should set the deepLinkPreference prop to universal,
+        // in which case this condition will be false, and the SDK will use WalletConnect (if available)
+        if (((_b = (_a = this.wallet) === null || _a === void 0 ? void 0 : _a.mobile) === null || _b === void 0 ? void 0 : _b.inAppBrowser) &&
+            this.mobileExperience === 'in-app-browser' &&
+            utils.isMobile()) {
+            return this;
+        }
+        // this is the case where the wallet is not installed on the browser and
+        // it does not support WalletConnect. in this case, the SDK will instruct
+        // the user to download the wallet extension
+        if (!this.walletConnectorFallback) {
+            return this;
+        }
+        return new walletConnect.WalletConnect(Object.assign(Object.assign({}, this.constructorProps), { walletName: this.name }));
+    }
+    setupEventListeners() {
+        const provider = this.getWalletClient();
+        if (!provider)
+            return;
+        const ethProviderHelper = this.getEthProviderHelper();
+        if (!ethProviderHelper)
+            return;
+        const { tearDownEventListeners } = ethProviderHelper._setupEventListeners(this);
+        this.teardownEventListeners = tearDownEventListeners;
+    }
+    getWalletClient(chainId) {
+        var _a;
+        return (_a = this.getEthProviderHelper()) === null || _a === void 0 ? void 0 : _a.findWalletClient(chainId);
+    }
+    isInstalledOnBrowser() {
+        var _a;
+        return ((_a = this.getEthProviderHelper()) === null || _a === void 0 ? void 0 : _a.findProvider()) !== undefined;
+    }
+    getAddress() {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            var _a;
+            return (_a = this.getEthProviderHelper()) === null || _a === void 0 ? void 0 : _a.getAddress();
+        });
+    }
+    connect() {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            yield this.getAddress();
+        });
+    }
+    signMessage(messageToSign) {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            var _a;
+            return (_a = this.getEthProviderHelper()) === null || _a === void 0 ? void 0 : _a.signMessage(messageToSign);
+        });
+    }
+    proveOwnership(messageToSign) {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            return this.signMessage(messageToSign);
+        });
+    }
+    endSession() {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            // nothing to do on browser-based metamask
+            return;
+        });
+    }
+    providerSwitchNetwork(_a) {
+        const _super = Object.create(null, {
+            providerSwitchNetwork: { get: () => super.providerSwitchNetwork }
+        });
+        return _tslib.__awaiter(this, arguments, void 0, function* ({ network, provider, }) {
+            return _super.providerSwitchNetwork.call(this, { network, provider });
+        });
+    }
+}
+
+module.exports = InjectedWalletBase;