@wagmi/core 0.2.0-next.9 → 0.2.2

package/connectors/coinbaseWallet/dist/wagmi-core-connectors-coinbaseWallet.esm.js

@@ -0,0 +1,212 @@
+import { c as Connector, _ as _defineProperty, m as _classPrivateFieldInitSpec, n as normalizeChainId, U as UserRejectedRequestError, p as _classPrivateFieldGet, o as _classPrivateFieldSet, a as allChains, k as ChainNotConfiguredError, A as AddChainError, l as SwitchChainError } from '../../../dist/base-159de546.esm.js';
+import { providers } from 'ethers';
+import { getAddress, hexValue } from 'ethers/lib/utils';
+import 'eventemitter3';
+
+var _client = /*#__PURE__*/new WeakMap();
+
+var _provider = /*#__PURE__*/new WeakMap();
+
+class CoinbaseWalletConnector extends Connector {
+  constructor(config) {
+    super(config);
+
+    _defineProperty(this, "id", 'coinbaseWallet');
+
+    _defineProperty(this, "name", 'Coinbase Wallet');
+
+    _defineProperty(this, "ready", true);
+
+    _classPrivateFieldInitSpec(this, _client, {
+      writable: true,
+      value: void 0
+    });
+
+    _classPrivateFieldInitSpec(this, _provider, {
+      writable: true,
+      value: void 0
+    });
+
+    _defineProperty(this, "onAccountsChanged", accounts => {
+      if (accounts.length === 0) this.emit('disconnect');else this.emit('change', {
+        account: getAddress(accounts[0])
+      });
+    });
+
+    _defineProperty(this, "onChainChanged", chainId => {
+      const id = normalizeChainId(chainId);
+      const unsupported = this.isChainUnsupported(id);
+      this.emit('change', {
+        chain: {
+          id,
+          unsupported
+        }
+      });
+    });
+
+    _defineProperty(this, "onDisconnect", () => {
+      this.emit('disconnect');
+    });
+  }
+
+  async connect() {
+    try {
+      const provider = await this.getProvider();
+      provider.on('accountsChanged', this.onAccountsChanged);
+      provider.on('chainChanged', this.onChainChanged);
+      provider.on('disconnect', this.onDisconnect);
+      this.emit('message', {
+        type: 'connecting'
+      });
+      const accounts = await provider.enable();
+      const account = getAddress(accounts[0]);
+      const id = await this.getChainId();
+      const unsupported = this.isChainUnsupported(id);
+      return {
+        account,
+        chain: {
+          id,
+          unsupported
+        },
+        provider: new providers.Web3Provider(provider)
+      };
+    } catch (error) {
+      if (/(user closed modal|accounts received is empty)/i.test(error.message)) throw new UserRejectedRequestError();
+      throw error;
+    }
+  }
+
+  async disconnect() {
+    if (!_classPrivateFieldGet(this, _provider)) return;
+    const provider = await this.getProvider();
+    provider.removeListener('accountsChanged', this.onAccountsChanged);
+    provider.removeListener('chainChanged', this.onChainChanged);
+    provider.removeListener('disconnect', this.onDisconnect);
+    provider.disconnect();
+    provider.close();
+
+    if (typeof localStorage !== 'undefined') {
+      let n = localStorage.length;
+
+      while (n--) {
+        const key = localStorage.key(n);
+        if (!key) continue;
+        if (!/-walletlink/.test(key)) continue;
+        localStorage.removeItem(key);
+      }
+    }
+  }
+
+  async getAccount() {
+    const provider = await this.getProvider();
+    const accounts = await provider.request({
+      method: 'eth_accounts'
+    }); // return checksum address
+
+    return getAddress(accounts[0]);
+  }
+
+  async getChainId() {
+    const provider = await this.getProvider();
+    const chainId = normalizeChainId(provider.chainId);
+    return chainId;
+  }
+
+  async getProvider() {
+    if (!_classPrivateFieldGet(this, _provider)) {
+      const {
+        CoinbaseWalletSDK
+      } = await import('@coinbase/wallet-sdk');
+
+      _classPrivateFieldSet(this, _client, new CoinbaseWalletSDK(this.options));
+
+      _classPrivateFieldSet(this, _provider, _classPrivateFieldGet(this, _client).makeWeb3Provider(this.options.jsonRpcUrl, this.options.chainId));
+    }
+
+    return _classPrivateFieldGet(this, _provider);
+  }
+
+  async getSigner() {
+    const [provider, account] = await Promise.all([this.getProvider(), this.getAccount()]);
+    return new providers.Web3Provider(provider).getSigner(account);
+  }
+
+  async isAuthorized() {
+    try {
+      const account = await this.getAccount();
+      return !!account;
+    } catch {
+      return false;
+    }
+  }
+
+  async switchChain(chainId) {
+    const provider = await this.getProvider();
+    const id = hexValue(chainId);
+
+    try {
+      var _chains$find;
+
+      await provider.request({
+        method: 'wallet_switchEthereumChain',
+        params: [{
+          chainId: id
+        }]
+      });
+      const chains = [...this.chains, ...allChains];
+      return (_chains$find = chains.find(x => x.id === chainId)) !== null && _chains$find !== void 0 ? _chains$find : {
+        id: chainId,
+        name: "Chain ".concat(id),
+        rpcUrls: {
+          default: ''
+        }
+      };
+    } catch (error) {
+      // Indicates chain is not added to provider
+      if (error.code === 4902) {
+        try {
+          const chain = this.chains.find(x => x.id === chainId);
+          if (!chain) throw new ChainNotConfiguredError();
+          await provider.request({
+            method: 'wallet_addEthereumChain',
+            params: [{
+              chainId: id,
+              chainName: chain.name,
+              nativeCurrency: chain.nativeCurrency,
+              rpcUrls: [chain.rpcUrls.default],
+              blockExplorerUrls: this.getBlockExplorerUrls(chain)
+            }]
+          });
+          return chain;
+        } catch (addError) {
+          throw new AddChainError();
+        }
+      } else if (error.code === 4001) throw new UserRejectedRequestError();else throw new SwitchChainError();
+    }
+  }
+
+  async watchAsset(_ref) {
+    let {
+      address,
+      decimals = 18,
+      image,
+      symbol
+    } = _ref;
+    const provider = await this.getProvider();
+    return await provider.request({
+      method: 'wallet_watchAsset',
+      params: {
+        type: 'ERC20',
+        options: {
+          address,
+          decimals,
+          image,
+          symbol
+        }
+      }
+    });
+  }
+
+}
+
+export { CoinbaseWalletConnector };

package/connectors/metaMask/dist/wagmi-core-connectors-metaMask.cjs.d.ts

@@ -0,0 +1 @@
+export * from "../../../dist/declarations/src/connectors/metaMask";

package/connectors/metaMask/dist/wagmi-core-connectors-metaMask.cjs.dev.js

@@ -0,0 +1,62 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var classPrivateMethodGet = require('../../../dist/classPrivateMethodGet-976c8120.cjs.dev.js');
+var base = require('../../../dist/base-5812b724.cjs.dev.js');
+var client = require('../../../dist/client-f77a08e4.cjs.dev.js');
+require('eventemitter3');
+require('ethers');
+require('zustand/vanilla');
+require('zustand/middleware');
+require('ethers/lib/utils');
+
+var _provider = /*#__PURE__*/new WeakMap();
+
+var _getReady = /*#__PURE__*/new WeakSet();
+
+var _findProvider = /*#__PURE__*/new WeakSet();
+
+class MetaMaskConnector extends client.InjectedConnector {
+  constructor(config) {
+    super({ ...config,
+      options: {
+        name: 'MetaMask',
+        shimDisconnect: true,
+        ...(config === null || config === void 0 ? void 0 : config.options)
+      }
+    });
+
+    classPrivateMethodGet._classPrivateMethodInitSpec(this, _findProvider);
+
+    classPrivateMethodGet._classPrivateMethodInitSpec(this, _getReady);
+
+    base._defineProperty(this, "id", 'metaMask');
+
+    base._defineProperty(this, "ready", typeof window != 'undefined' && !!classPrivateMethodGet._classPrivateMethodGet(this, _findProvider, _findProvider2).call(this, window.ethereum));
+
+    base._classPrivateFieldInitSpec(this, _provider, {
+      writable: true,
+      value: void 0
+    });
+  }
+
+  async getProvider() {
+    if (typeof window !== 'undefined') base._classPrivateFieldSet(this, _provider, classPrivateMethodGet._classPrivateMethodGet(this, _findProvider, _findProvider2).call(this, window.ethereum));
+    return base._classPrivateFieldGet(this, _provider);
+  }
+
+}
+
+function _getReady2(ethereum) {
+  const isMetaMask = !!(ethereum !== null && ethereum !== void 0 && ethereum.isMetaMask); // Brave Wallet tries to make itself look like MetaMask
+
+  if (isMetaMask && !ethereum.isBraveWallet) return ethereum;
+}
+
+function _findProvider2(ethereum) {
+  if (ethereum !== null && ethereum !== void 0 && ethereum.providers) return ethereum.providers.find(classPrivateMethodGet._classPrivateMethodGet(this, _getReady, _getReady2));
+  return classPrivateMethodGet._classPrivateMethodGet(this, _getReady, _getReady2).call(this, ethereum);
+}
+
+exports.MetaMaskConnector = MetaMaskConnector;

package/connectors/metaMask/dist/wagmi-core-connectors-metaMask.cjs.js

@@ -0,0 +1,7 @@
+'use strict';
+
+if (process.env.NODE_ENV === "production") {
+  module.exports = require("./wagmi-core-connectors-metaMask.cjs.prod.js");
+} else {
+  module.exports = require("./wagmi-core-connectors-metaMask.cjs.dev.js");
+}

package/connectors/metaMask/dist/wagmi-core-connectors-metaMask.cjs.prod.js

@@ -0,0 +1,62 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var classPrivateMethodGet = require('../../../dist/classPrivateMethodGet-d7330ed7.cjs.prod.js');
+var base = require('../../../dist/base-59f3457e.cjs.prod.js');
+var client = require('../../../dist/client-4d8337e7.cjs.prod.js');
+require('eventemitter3');
+require('ethers');
+require('zustand/vanilla');
+require('zustand/middleware');
+require('ethers/lib/utils');
+
+var _provider = /*#__PURE__*/new WeakMap();
+
+var _getReady = /*#__PURE__*/new WeakSet();
+
+var _findProvider = /*#__PURE__*/new WeakSet();
+
+class MetaMaskConnector extends client.InjectedConnector {
+  constructor(config) {
+    super({ ...config,
+      options: {
+        name: 'MetaMask',
+        shimDisconnect: true,
+        ...(config === null || config === void 0 ? void 0 : config.options)
+      }
+    });
+
+    classPrivateMethodGet._classPrivateMethodInitSpec(this, _findProvider);
+
+    classPrivateMethodGet._classPrivateMethodInitSpec(this, _getReady);
+
+    base._defineProperty(this, "id", 'metaMask');
+
+    base._defineProperty(this, "ready", typeof window != 'undefined' && !!classPrivateMethodGet._classPrivateMethodGet(this, _findProvider, _findProvider2).call(this, window.ethereum));
+
+    base._classPrivateFieldInitSpec(this, _provider, {
+      writable: true,
+      value: void 0
+    });
+  }
+
+  async getProvider() {
+    if (typeof window !== 'undefined') base._classPrivateFieldSet(this, _provider, classPrivateMethodGet._classPrivateMethodGet(this, _findProvider, _findProvider2).call(this, window.ethereum));
+    return base._classPrivateFieldGet(this, _provider);
+  }
+
+}
+
+function _getReady2(ethereum) {
+  const isMetaMask = !!(ethereum !== null && ethereum !== void 0 && ethereum.isMetaMask); // Brave Wallet tries to make itself look like MetaMask
+
+  if (isMetaMask && !ethereum.isBraveWallet) return ethereum;
+}
+
+function _findProvider2(ethereum) {
+  if (ethereum !== null && ethereum !== void 0 && ethereum.providers) return ethereum.providers.find(classPrivateMethodGet._classPrivateMethodGet(this, _getReady, _getReady2));
+  return classPrivateMethodGet._classPrivateMethodGet(this, _getReady, _getReady2).call(this, ethereum);
+}
+
+exports.MetaMaskConnector = MetaMaskConnector;

package/connectors/metaMask/dist/wagmi-core-connectors-metaMask.esm.js

@@ -0,0 +1,58 @@
+import { _ as _classPrivateMethodInitSpec, a as _classPrivateMethodGet } from '../../../dist/classPrivateMethodGet-55c9909f.esm.js';
+import { _ as _defineProperty, m as _classPrivateFieldInitSpec, o as _classPrivateFieldSet, p as _classPrivateFieldGet } from '../../../dist/base-159de546.esm.js';
+import { I as InjectedConnector } from '../../../dist/client-5d456446.esm.js';
+import 'eventemitter3';
+import 'ethers';
+import 'zustand/vanilla';
+import 'zustand/middleware';
+import 'ethers/lib/utils';
+
+var _provider = /*#__PURE__*/new WeakMap();
+
+var _getReady = /*#__PURE__*/new WeakSet();
+
+var _findProvider = /*#__PURE__*/new WeakSet();
+
+class MetaMaskConnector extends InjectedConnector {
+  constructor(config) {
+    super({ ...config,
+      options: {
+        name: 'MetaMask',
+        shimDisconnect: true,
+        ...(config === null || config === void 0 ? void 0 : config.options)
+      }
+    });
+
+    _classPrivateMethodInitSpec(this, _findProvider);
+
+    _classPrivateMethodInitSpec(this, _getReady);
+
+    _defineProperty(this, "id", 'metaMask');
+
+    _defineProperty(this, "ready", typeof window != 'undefined' && !!_classPrivateMethodGet(this, _findProvider, _findProvider2).call(this, window.ethereum));
+
+    _classPrivateFieldInitSpec(this, _provider, {
+      writable: true,
+      value: void 0
+    });
+  }
+
+  async getProvider() {
+    if (typeof window !== 'undefined') _classPrivateFieldSet(this, _provider, _classPrivateMethodGet(this, _findProvider, _findProvider2).call(this, window.ethereum));
+    return _classPrivateFieldGet(this, _provider);
+  }
+
+}
+
+function _getReady2(ethereum) {
+  const isMetaMask = !!(ethereum !== null && ethereum !== void 0 && ethereum.isMetaMask); // Brave Wallet tries to make itself look like MetaMask
+
+  if (isMetaMask && !ethereum.isBraveWallet) return ethereum;
+}
+
+function _findProvider2(ethereum) {
+  if (ethereum !== null && ethereum !== void 0 && ethereum.providers) return ethereum.providers.find(_classPrivateMethodGet(this, _getReady, _getReady2));
+  return _classPrivateMethodGet(this, _getReady, _getReady2).call(this, ethereum);
+}
+
+export { MetaMaskConnector };

package/connectors/metaMask/package.json

@@ -0,0 +1,4 @@
+{
+  "main": "dist/wagmi-core-connectors-metaMask.cjs.js",
+  "module": "dist/wagmi-core-connectors-metaMask.esm.js"
+}

package/connectors/mock/dist/wagmi-core-connectors-mock.cjs.d.ts

@@ -1,11 +1 @@
-// are you seeing an error that a default export doesn't exist but your source file has a default export?
-// you should run `yarn` or `yarn preconstruct dev` if preconstruct dev isn't in your postinstall hook
-
-// curious why you need to?
-// this file exists so that you can import from the entrypoint normally
-// except that it points to your source file and you don't need to run build constantly
-// which means we need to re-export all of the modules from your source file
-// and since export * doesn't include default exports, we need to read your source file
-// to check for a default export and re-export it if it exists
-// it's not ideal, but it works pretty well ¯\_(ツ)_/¯
-export * from "../../../src/connectors/mock/index";
+export * from "../../../dist/declarations/src/connectors/mock/index";

package/connectors/mock/dist/wagmi-core-connectors-mock.cjs.dev.js

@@ -0,0 +1,250 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var classPrivateMethodGet = require('../../../dist/classPrivateMethodGet-976c8120.cjs.dev.js');
+var base = require('../../../dist/base-5812b724.cjs.dev.js');
+var utils = require('ethers/lib/utils');
+var EventEmitter = require('eventemitter3');
+var ethers = require('ethers');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { 'default': e }; }
+
+var EventEmitter__default = /*#__PURE__*/_interopDefault(EventEmitter);
+
+var _options = /*#__PURE__*/new WeakMap();
+
+var _signer = /*#__PURE__*/new WeakMap();
+
+class MockProvider extends ethers.providers.BaseProvider {
+  constructor(options) {
+    var _options$network;
+
+    super((_options$network = options.network) !== null && _options$network !== void 0 ? _options$network : 1);
+
+    base._defineProperty(this, "events", new EventEmitter__default["default"]());
+
+    base._classPrivateFieldInitSpec(this, _options, {
+      writable: true,
+      value: void 0
+    });
+
+    base._classPrivateFieldInitSpec(this, _signer, {
+      writable: true,
+      value: void 0
+    });
+
+    base._classPrivateFieldSet(this, _options, options);
+  }
+
+  async enable() {
+    var _classPrivateFieldGet2;
+
+    if ((_classPrivateFieldGet2 = base._classPrivateFieldGet(this, _options).flags) !== null && _classPrivateFieldGet2 !== void 0 && _classPrivateFieldGet2.failConnect) throw new base.UserRejectedRequestError();
+    if (!base._classPrivateFieldGet(this, _signer)) base._classPrivateFieldSet(this, _signer, base._classPrivateFieldGet(this, _options).signer);
+    const address = await base._classPrivateFieldGet(this, _signer).getAddress();
+    this.events.emit('accountsChanged', [address]);
+    return [address];
+  }
+
+  async disconnect() {
+    this.events.emit('disconnect');
+
+    base._classPrivateFieldSet(this, _signer, undefined);
+  }
+
+  async getAccounts() {
+    var _classPrivateFieldGet3;
+
+    const address = await ((_classPrivateFieldGet3 = base._classPrivateFieldGet(this, _signer)) === null || _classPrivateFieldGet3 === void 0 ? void 0 : _classPrivateFieldGet3.getAddress());
+    if (!address) return [];
+    return [utils.getAddress(address)];
+  }
+
+  getSigner() {
+    const signer = base._classPrivateFieldGet(this, _signer);
+
+    if (!signer) throw new Error('Signer not found');
+    return signer;
+  }
+
+  async switchChain(chainId) {
+    var _classPrivateFieldGet4;
+
+    if ((_classPrivateFieldGet4 = base._classPrivateFieldGet(this, _options).flags) !== null && _classPrivateFieldGet4 !== void 0 && _classPrivateFieldGet4.failSwitchChain) throw new base.UserRejectedRequestError();
+    base._classPrivateFieldGet(this, _options).network = chainId;
+    this.network.chainId = chainId;
+    this.events.emit('chainChanged', chainId);
+  }
+
+  async watchAsset(_asset) {
+    return true;
+  }
+
+  on(event, listener) {
+    this.events.on(event, listener);
+    return this;
+  }
+
+  once(event, listener) {
+    this.events.once(event, listener);
+    return this;
+  }
+
+  removeListener(event, listener) {
+    this.events.removeListener(event, listener);
+    return this;
+  }
+
+  off(event, listener) {
+    this.events.off(event, listener);
+    return this;
+  }
+
+  toJSON() {
+    return '<MockProvider>';
+  }
+
+}
+
+var _provider = /*#__PURE__*/new WeakMap();
+
+var _switchChain = /*#__PURE__*/new WeakSet();
+
+class MockConnector extends base.Connector {
+  constructor(config) {
+    super(config);
+
+    classPrivateMethodGet._classPrivateMethodInitSpec(this, _switchChain);
+
+    base._defineProperty(this, "id", 'mock');
+
+    base._defineProperty(this, "name", 'Mock');
+
+    base._defineProperty(this, "ready", true);
+
+    base._classPrivateFieldInitSpec(this, _provider, {
+      writable: true,
+      value: void 0
+    });
+
+    base._defineProperty(this, "onAccountsChanged", accounts => {
+      if (accounts.length === 0) this.emit('disconnect');else this.emit('change', {
+        account: utils.getAddress(accounts[0])
+      });
+    });
+
+    base._defineProperty(this, "onChainChanged", chainId => {
+      const id = base.normalizeChainId(chainId);
+      const unsupported = this.isChainUnsupported(id);
+      this.emit('change', {
+        chain: {
+          id,
+          unsupported
+        }
+      });
+    });
+
+    base._defineProperty(this, "onDisconnect", () => {
+      this.emit('disconnect');
+    });
+  }
+
+  async connect() {
+    var _this$options$flags;
+
+    const provider = await this.getProvider();
+    provider.on('accountsChanged', this.onAccountsChanged);
+    provider.on('chainChanged', this.onChainChanged);
+    provider.on('disconnect', this.onDisconnect);
+    this.emit('message', {
+      type: 'connecting'
+    });
+    const accounts = await provider.enable();
+    const account = utils.getAddress(accounts[0]);
+    const id = base.normalizeChainId(provider._network.chainId);
+    const unsupported = this.isChainUnsupported(id);
+    const data = {
+      account,
+      chain: {
+        id,
+        unsupported
+      },
+      provider
+    };
+    if (!((_this$options$flags = this.options.flags) !== null && _this$options$flags !== void 0 && _this$options$flags.noSwitchChain)) this.switchChain = classPrivateMethodGet._classPrivateMethodGet(this, _switchChain, _switchChain2);
+    return data;
+  }
+
+  async disconnect() {
+    const provider = await this.getProvider();
+    await provider.disconnect();
+    provider.removeListener('accountsChanged', this.onAccountsChanged);
+    provider.removeListener('chainChanged', this.onChainChanged);
+    provider.removeListener('disconnect', this.onDisconnect);
+  }
+
+  async getAccount() {
+    const provider = await this.getProvider();
+    const accounts = await provider.getAccounts();
+    const account = accounts[0];
+    if (!account) throw new Error('Failed to get account'); // return checksum address
+
+    return utils.getAddress(account);
+  }
+
+  async getChainId() {
+    const provider = await this.getProvider();
+    return base.normalizeChainId(provider.network.chainId);
+  }
+
+  async getProvider() {
+    if (!base._classPrivateFieldGet(this, _provider)) base._classPrivateFieldSet(this, _provider, new MockProvider(this.options));
+    return base._classPrivateFieldGet(this, _provider);
+  }
+
+  async getSigner() {
+    const provider = await this.getProvider();
+    return provider.getSigner();
+  }
+
+  async isAuthorized() {
+    try {
+      var _this$options$flags$i, _this$options$flags2;
+
+      const provider = await this.getProvider();
+      const account = await provider.getAccounts();
+      return (_this$options$flags$i = (_this$options$flags2 = this.options.flags) === null || _this$options$flags2 === void 0 ? void 0 : _this$options$flags2.isAuthorized) !== null && _this$options$flags$i !== void 0 ? _this$options$flags$i : !!account;
+    } catch {
+      return false;
+    }
+  }
+
+  async watchAsset(asset) {
+    const provider = await this.getProvider();
+    return await provider.watchAsset(asset);
+  }
+
+  toJSON() {
+    return '<MockConnector>';
+  }
+
+}
+
+async function _switchChain2(chainId) {
+  var _chains$find;
+
+  const provider = await this.getProvider();
+  await provider.switchChain(chainId);
+  const chains = [...this.chains, ...base.allChains];
+  return (_chains$find = chains.find(x => x.id === chainId)) !== null && _chains$find !== void 0 ? _chains$find : {
+    id: chainId,
+    name: "Chain ".concat(chainId),
+    rpcUrls: {
+      default: ''
+    }
+  };
+}
+
+exports.MockConnector = MockConnector;
+exports.MockProvider = MockProvider;