@wagmi/core 0.2.0-next.0

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

@@ -0,0 +1,230 @@
+import { C as Connector, _ as _defineProperty, a as _classPrivateFieldInitSpec, n as normalizeChainId, b as _asyncToGenerator, U as UserRejectedRequestError, e as _classPrivateFieldGet, d as _classPrivateFieldSet, f as allChains, S as SwitchChainError } from '../../../dist/base-824c3b6d.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) {
+    var _window$ethereum;
+
+    super(config);
+
+    _defineProperty(this, "id", 'coinbaseWallet');
+
+    _defineProperty(this, "name", 'Coinbase Wallet');
+
+    _defineProperty(this, "ready", typeof window !== 'undefined' && !((_window$ethereum = window.ethereum) !== null && _window$ethereum !== void 0 && _window$ethereum.isCoinbaseWallet));
+
+    _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 => {
+      var id = normalizeChainId(chainId);
+      var unsupported = this.isChainUnsupported(id);
+      this.emit('change', {
+        chain: {
+          id,
+          unsupported
+        }
+      });
+    });
+
+    _defineProperty(this, "onDisconnect", () => {
+      this.emit('disconnect');
+    });
+  }
+
+  connect() {
+    var _this = this;
+
+    return _asyncToGenerator(function* () {
+      try {
+        var provider = yield _this.getProvider();
+        provider.on('accountsChanged', _this.onAccountsChanged);
+        provider.on('chainChanged', _this.onChainChanged);
+        provider.on('disconnect', _this.onDisconnect);
+        var accounts = yield provider.enable();
+        var account = getAddress(accounts[0]);
+        var id = yield _this.getChainId();
+
+        var unsupported = _this.isChainUnsupported(id);
+
+        return {
+          account,
+          chain: {
+            id,
+            unsupported
+          },
+          provider: new providers.Web3Provider(provider)
+        };
+      } catch (error) {
+        if (/user closed modal/i.test(error.message)) throw new UserRejectedRequestError();
+        throw error;
+      }
+    })();
+  }
+
+  disconnect() {
+    var _this2 = this;
+
+    return _asyncToGenerator(function* () {
+      if (!_classPrivateFieldGet(_this2, _provider)) return;
+      var provider = yield _this2.getProvider();
+      provider.removeListener('accountsChanged', _this2.onAccountsChanged);
+      provider.removeListener('chainChanged', _this2.onChainChanged);
+      provider.removeListener('disconnect', _this2.onDisconnect);
+      provider.disconnect();
+      provider.close();
+
+      if (typeof localStorage !== 'undefined') {
+        var n = localStorage.length;
+
+        while (n--) {
+          var key = localStorage.key(n);
+          if (!key) continue;
+          if (!/-walletlink/.test(key)) continue;
+          localStorage.removeItem(key);
+        }
+      }
+    })();
+  }
+
+  getAccount() {
+    var _this3 = this;
+
+    return _asyncToGenerator(function* () {
+      var provider = yield _this3.getProvider();
+      var accounts = yield provider.request({
+        method: 'eth_accounts'
+      }); // return checksum address
+
+      return getAddress(accounts[0]);
+    })();
+  }
+
+  getChainId() {
+    var _this4 = this;
+
+    return _asyncToGenerator(function* () {
+      var provider = yield _this4.getProvider();
+      var chainId = normalizeChainId(provider.chainId);
+      return chainId;
+    })();
+  }
+
+  getProvider() {
+    var _this5 = this;
+
+    return _asyncToGenerator(function* () {
+      if (!_classPrivateFieldGet(_this5, _provider)) {
+        var {
+          CoinbaseWalletSDK
+        } = yield import('@coinbase/wallet-sdk');
+
+        _classPrivateFieldSet(_this5, _client, new CoinbaseWalletSDK(_this5.options));
+
+        _classPrivateFieldSet(_this5, _provider, _classPrivateFieldGet(_this5, _client).makeWeb3Provider(_this5.options.jsonRpcUrl));
+      }
+
+      return _classPrivateFieldGet(_this5, _provider);
+    })();
+  }
+
+  getSigner() {
+    var _this6 = this;
+
+    return _asyncToGenerator(function* () {
+      var provider = _this6.getProvider();
+
+      var account = yield _this6.getAccount();
+      return new providers.Web3Provider(provider).getSigner(account);
+    })();
+  }
+
+  isAuthorized() {
+    var _this7 = this;
+
+    return _asyncToGenerator(function* () {
+      try {
+        var account = yield _this7.getAccount();
+        return !!account;
+      } catch (_unused) {
+        return false;
+      }
+    })();
+  }
+
+  switchChain(chainId) {
+    var _this8 = this;
+
+    return _asyncToGenerator(function* () {
+      var provider = yield _this8.getProvider();
+      var id = hexValue(chainId);
+
+      try {
+        var _chains$find;
+
+        yield provider.request({
+          method: 'wallet_switchEthereumChain',
+          params: [{
+            chainId: id
+          }]
+        });
+        var chains = [..._this8.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: []
+        };
+      } catch (error) {
+        if (/user rejected signature request/i.test(error.message)) throw new UserRejectedRequestError();else throw new SwitchChainError();
+      }
+    })();
+  }
+
+  watchAsset(_ref) {
+    var _this9 = this;
+
+    return _asyncToGenerator(function* () {
+      var {
+        address,
+        decimals = 18,
+        image,
+        symbol
+      } = _ref;
+      var provider = yield _this9.getProvider();
+      return yield provider.request({
+        method: 'wallet_watchAsset',
+        params: {
+          type: 'ERC20',
+          options: {
+            address,
+            decimals,
+            image,
+            symbol
+          }
+        }
+      });
+    })();
+  }
+
+}
+
+export { CoinbaseWalletConnector };

package/connectors/coinbaseWallet/package.json

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

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

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

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

@@ -0,0 +1,304 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var base = require('../../../dist/base-09a653f3.cjs.dev.js');
+var classPrivateMethodGet = require('../../../dist/classPrivateMethodGet-38b54c7a.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);
+  }
+
+  enable() {
+    var _this = this;
+
+    return base._asyncToGenerator(function* () {
+      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);
+      var address = yield base._classPrivateFieldGet(_this, _signer).getAddress();
+
+      _this.events.emit('accountsChanged', [address]);
+
+      return [address];
+    })();
+  }
+
+  disconnect() {
+    var _this2 = this;
+
+    return base._asyncToGenerator(function* () {
+      _this2.events.emit('disconnect');
+
+      base._classPrivateFieldSet(_this2, _signer, undefined);
+    })();
+  }
+
+  getAccounts() {
+    var _this3 = this;
+
+    return base._asyncToGenerator(function* () {
+      var _classPrivateFieldGet3;
+
+      var address = yield (_classPrivateFieldGet3 = base._classPrivateFieldGet(_this3, _signer)) === null || _classPrivateFieldGet3 === void 0 ? void 0 : _classPrivateFieldGet3.getAddress();
+      if (!address) return [];
+      return [utils.getAddress(address)];
+    })();
+  }
+
+  getSigner() {
+    var signer = base._classPrivateFieldGet(this, _signer);
+
+    if (!signer) throw new Error('Signer not found');
+    return signer;
+  }
+
+  switchChain(chainId) {
+    var _this4 = this;
+
+    return base._asyncToGenerator(function* () {
+      base._classPrivateFieldGet(_this4, _options).network = chainId;
+      _this4.network.chainId = chainId;
+
+      _this4.events.emit('chainChanged', chainId);
+    })();
+  }
+
+  watchAsset(_asset) {
+    return base._asyncToGenerator(function* () {
+      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 => {
+      var id = base.normalizeChainId(chainId);
+      var unsupported = this.isChainUnsupported(id);
+      this.emit('change', {
+        chain: {
+          id,
+          unsupported
+        }
+      });
+    });
+
+    base._defineProperty(this, "onDisconnect", () => {
+      this.emit('disconnect');
+    });
+  }
+
+  connect() {
+    var _this = this;
+
+    return base._asyncToGenerator(function* () {
+      var _this$options$flags;
+
+      var provider = yield _this.getProvider();
+      provider.on('accountsChanged', _this.onAccountsChanged);
+      provider.on('chainChanged', _this.onChainChanged);
+      provider.on('disconnect', _this.onDisconnect);
+      var accounts = yield provider.enable();
+      var account = utils.getAddress(accounts[0]);
+      var id = base.normalizeChainId(provider._network.chainId);
+
+      var unsupported = _this.isChainUnsupported(id);
+
+      var data = {
+        account,
+        chain: {
+          id,
+          unsupported
+        },
+        provider
+      };
+      if (!((_this$options$flags = _this.options.flags) !== null && _this$options$flags !== void 0 && _this$options$flags.failSwitchChain)) _this.switchChain = classPrivateMethodGet._classPrivateMethodGet(_this, _switchChain, _switchChain2);
+      return data;
+    })();
+  }
+
+  disconnect() {
+    var _this2 = this;
+
+    return base._asyncToGenerator(function* () {
+      var provider = yield _this2.getProvider();
+      yield provider.disconnect();
+      provider.removeListener('accountsChanged', _this2.onAccountsChanged);
+      provider.removeListener('chainChanged', _this2.onChainChanged);
+      provider.removeListener('disconnect', _this2.onDisconnect);
+    })();
+  }
+
+  getAccount() {
+    var _this3 = this;
+
+    return base._asyncToGenerator(function* () {
+      var provider = yield _this3.getProvider();
+      var accounts = yield provider.getAccounts();
+      var account = accounts[0];
+      if (!account) throw new Error('Failed to get account'); // return checksum address
+
+      return utils.getAddress(account);
+    })();
+  }
+
+  getChainId() {
+    var _this4 = this;
+
+    return base._asyncToGenerator(function* () {
+      var provider = yield _this4.getProvider();
+      var chainId = base.normalizeChainId(provider.network.chainId);
+      return chainId;
+    })();
+  }
+
+  getProvider() {
+    var _this5 = this;
+
+    return base._asyncToGenerator(function* () {
+      if (!base._classPrivateFieldGet(_this5, _provider)) base._classPrivateFieldSet(_this5, _provider, new MockProvider(_this5.options));
+      return base._classPrivateFieldGet(_this5, _provider);
+    })();
+  }
+
+  getSigner() {
+    var _this6 = this;
+
+    return base._asyncToGenerator(function* () {
+      var provider = yield _this6.getProvider();
+      var signer = provider.getSigner();
+      return signer;
+    })();
+  }
+
+  isAuthorized() {
+    var _this7 = this;
+
+    return base._asyncToGenerator(function* () {
+      try {
+        var provider = yield _this7.getProvider();
+        var account = yield provider.getAccounts();
+        return !!account;
+      } catch (_unused) {
+        return false;
+      }
+    })();
+  }
+
+  watchAsset(asset) {
+    var _this8 = this;
+
+    return base._asyncToGenerator(function* () {
+      var provider = yield _this8.getProvider();
+      return yield provider.watchAsset(asset);
+    })();
+  }
+
+  toJSON() {
+    return '<MockConnector>';
+  }
+
+}
+
+function _switchChain2(_x) {
+  return _switchChain3.apply(this, arguments);
+}
+
+function _switchChain3() {
+  _switchChain3 = base._asyncToGenerator(function* (chainId) {
+    var _chains$find;
+
+    var provider = yield this.getProvider();
+    yield provider.switchChain(chainId);
+    var 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: []
+    };
+  });
+  return _switchChain3.apply(this, arguments);
+}
+
+exports.MockConnector = MockConnector;
+exports.MockProvider = MockProvider;

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

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