@wagmi/core 0.0.0-20220909032847

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

@@ -0,0 +1,257 @@
+import { t as _defineProperty, v as _classPrivateFieldInitSpec, w as _classPrivateFieldSet, x as _classPrivateFieldGet, U as UserRejectedRequestError, l as Connector, _ as _classPrivateMethodInitSpec, n as normalizeChainId, u as _classPrivateMethodGet } from '../../../dist/getProvider-34b63ce9.esm.js';
+import { getAddress } from 'ethers/lib/utils';
+import { providers } from 'ethers';
+import EventEmitter from 'eventemitter3';
+import 'zustand/middleware';
+import 'zustand/vanilla';
+import '../../../dist/chains-de91362e.esm.js';
+import '../../../dist/rpcs-f39d022b.esm.js';
+
+var _options = /*#__PURE__*/new WeakMap();
+
+var _signer = /*#__PURE__*/new WeakMap();
+
+class MockProvider extends providers.BaseProvider {
+  constructor(options) {
+    var _options$chainId;
+
+    super({
+      name: 'Network',
+      chainId: (_options$chainId = options.chainId) !== null && _options$chainId !== void 0 ? _options$chainId : 1
+    });
+
+    _defineProperty(this, "events", new EventEmitter());
+
+    _classPrivateFieldInitSpec(this, _options, {
+      writable: true,
+      value: void 0
+    });
+
+    _classPrivateFieldInitSpec(this, _signer, {
+      writable: true,
+      value: void 0
+    });
+
+    _classPrivateFieldSet(this, _options, options);
+  }
+
+  async enable() {
+    var _classPrivateFieldGet2;
+
+    if ((_classPrivateFieldGet2 = _classPrivateFieldGet(this, _options).flags) !== null && _classPrivateFieldGet2 !== void 0 && _classPrivateFieldGet2.failConnect) throw new UserRejectedRequestError(new Error('Failed to connect'));
+    if (!_classPrivateFieldGet(this, _signer)) _classPrivateFieldSet(this, _signer, _classPrivateFieldGet(this, _options).signer);
+    const address = await _classPrivateFieldGet(this, _signer).getAddress();
+    this.events.emit('accountsChanged', [address]);
+    return [address];
+  }
+
+  async disconnect() {
+    this.events.emit('disconnect');
+
+    _classPrivateFieldSet(this, _signer, undefined);
+  }
+
+  async getAccounts() {
+    var _classPrivateFieldGet3;
+
+    const address = await ((_classPrivateFieldGet3 = _classPrivateFieldGet(this, _signer)) === null || _classPrivateFieldGet3 === void 0 ? void 0 : _classPrivateFieldGet3.getAddress());
+    if (!address) return [];
+    return [getAddress(address)];
+  }
+
+  getSigner() {
+    const signer = _classPrivateFieldGet(this, _signer);
+
+    if (!signer) throw new Error('Signer not found');
+    return signer;
+  }
+
+  async switchChain(chainId) {
+    var _classPrivateFieldGet4;
+
+    if ((_classPrivateFieldGet4 = _classPrivateFieldGet(this, _options).flags) !== null && _classPrivateFieldGet4 !== void 0 && _classPrivateFieldGet4.failSwitchChain) throw new UserRejectedRequestError(new Error('Failed to switch chain'));
+    _classPrivateFieldGet(this, _options).chainId = 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 Connector {
+  constructor(config) {
+    super(config);
+
+    _classPrivateMethodInitSpec(this, _switchChain);
+
+    _defineProperty(this, "id", 'mock');
+
+    _defineProperty(this, "name", 'Mock');
+
+    _defineProperty(this, "ready", true);
+
+    _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() {
+    var _this$options$flags;
+
+    let {
+      chainId
+    } = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+    const provider = await this.getProvider({
+      chainId
+    });
+    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 = 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(this, _switchChain, _switchChain2);
+    return new Promise(res => setTimeout(() => res(data), 100));
+  }
+
+  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 getAddress(account);
+  }
+
+  async getChainId() {
+    const provider = await this.getProvider();
+    return normalizeChainId(provider.network.chainId);
+  }
+
+  async getProvider() {
+    let {
+      chainId
+    } = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+    if (!_classPrivateFieldGet(this, _provider) || chainId) _classPrivateFieldSet(this, _provider, new MockProvider({ ...this.options,
+      chainId
+    }));
+    return _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 _this$chains$find;
+
+  const provider = await this.getProvider();
+  await provider.switchChain(chainId);
+  return (_this$chains$find = this.chains.find(x => x.id === chainId)) !== null && _this$chains$find !== void 0 ? _this$chains$find : {
+    id: chainId,
+    name: "Chain ".concat(chainId),
+    network: "".concat(chainId),
+    rpcUrls: {
+      default: ''
+    }
+  };
+}
+
+export { MockConnector, MockProvider };

package/connectors/mock/package.json

@@ -0,0 +1,3 @@
+{
+  "main": "dist/wagmi-core-connectors-mock.esm.js"
+}

package/connectors/walletConnect/dist/wagmi-core-connectors-walletConnect.esm.d.ts

@@ -0,0 +1,11 @@
+// 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/walletConnect";

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

@@ -0,0 +1,207 @@
+import { l as Connector, _ as _classPrivateMethodInitSpec, t as _defineProperty, v as _classPrivateFieldInitSpec, n as normalizeChainId, g as getClient, u as _classPrivateMethodGet, U as UserRejectedRequestError, x as _classPrivateFieldGet, w as _classPrivateFieldSet, q as SwitchChainError } from '../../../dist/getProvider-34b63ce9.esm.js';
+import { providers } from 'ethers';
+import { getAddress, hexValue } from 'ethers/lib/utils';
+import 'zustand/middleware';
+import 'zustand/vanilla';
+import 'eventemitter3';
+import '../../../dist/chains-de91362e.esm.js';
+import '../../../dist/rpcs-f39d022b.esm.js';
+
+/**
+ * Wallets that support chain switching through WalletConnect
+ * - imToken (token.im)
+ * - MetaMask (metamask.io)
+ * - Rainbow (rainbow.me)
+ */
+
+const switchChainAllowedRegex = /(imtoken|metamask|rainbow)/i;
+
+var _provider = /*#__PURE__*/new WeakMap();
+
+var _switchChain = /*#__PURE__*/new WeakSet();
+
+class WalletConnectConnector extends Connector {
+  constructor(config) {
+    super(config);
+
+    _classPrivateMethodInitSpec(this, _switchChain);
+
+    _defineProperty(this, "id", 'walletConnect');
+
+    _defineProperty(this, "name", 'WalletConnect');
+
+    _defineProperty(this, "ready", true);
+
+    _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() {
+    let {
+      chainId
+    } = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+
+    try {
+      var _provider$connector$p, _provider$connector, _provider$connector$p2;
+
+      let targetChainId = chainId;
+
+      if (!targetChainId) {
+        const lastUsedChainId = getClient().lastUsedChainId;
+        if (lastUsedChainId && !this.isChainUnsupported(lastUsedChainId)) targetChainId = lastUsedChainId;
+      }
+
+      const provider = await this.getProvider({
+        chainId: targetChainId,
+        create: true
+      });
+      provider.on('accountsChanged', this.onAccountsChanged);
+      provider.on('chainChanged', this.onChainChanged);
+      provider.on('disconnect', this.onDisconnect); // Defer message to the next tick to ensure wallet connect data (provided by `.enable()`) is available
+
+      setTimeout(() => this.emit('message', {
+        type: 'connecting'
+      }), 0);
+      const accounts = await provider.enable();
+      const account = getAddress(accounts[0]);
+      const id = await this.getChainId();
+      const unsupported = this.isChainUnsupported(id); // Not all WalletConnect options support programmatic chain switching
+      // Only enable for wallet options that do
+
+      const walletName = (_provider$connector$p = (_provider$connector = provider.connector) === null || _provider$connector === void 0 ? void 0 : (_provider$connector$p2 = _provider$connector.peerMeta) === null || _provider$connector$p2 === void 0 ? void 0 : _provider$connector$p2.name) !== null && _provider$connector$p !== void 0 ? _provider$connector$p : '';
+      if (switchChainAllowedRegex.test(walletName)) this.switchChain = _classPrivateMethodGet(this, _switchChain, _switchChain2);
+      return {
+        account,
+        chain: {
+          id,
+          unsupported
+        },
+        provider: new providers.Web3Provider(provider)
+      };
+    } catch (error) {
+      if (/user closed modal/i.test(error.message)) throw new UserRejectedRequestError(error);
+      throw error;
+    }
+  }
+
+  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);
+    typeof localStorage !== 'undefined' && localStorage.removeItem('walletconnect');
+  }
+
+  async getAccount() {
+    const provider = await this.getProvider();
+    const accounts = provider.accounts; // return checksum address
+
+    return getAddress(accounts[0]);
+  }
+
+  async getChainId() {
+    const provider = await this.getProvider();
+    const chainId = normalizeChainId(provider.chainId);
+    return chainId;
+  }
+
+  async getProvider() {
+    let {
+      chainId,
+      create
+    } = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+
+    // Force create new provider
+    if (!_classPrivateFieldGet(this, _provider) || chainId || create) {
+      var _this$options, _this$options2;
+
+      const rpc = !((_this$options = this.options) !== null && _this$options !== void 0 && _this$options.infuraId) ? this.chains.reduce((rpc, chain) => ({ ...rpc,
+        [chain.id]: chain.rpcUrls.default
+      }), {}) : {};
+      const WalletConnectProvider = (await import('@walletconnect/ethereum-provider')).default;
+
+      _classPrivateFieldSet(this, _provider, new WalletConnectProvider({ ...this.options,
+        chainId,
+        rpc: { ...rpc,
+          ...((_this$options2 = this.options) === null || _this$options2 === void 0 ? void 0 : _this$options2.rpc)
+        }
+      }));
+    }
+
+    return _classPrivateFieldGet(this, _provider);
+  }
+
+  async getSigner() {
+    let {
+      chainId
+    } = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+    const [provider, account] = await Promise.all([this.getProvider({
+      chainId
+    }), this.getAccount()]);
+    return new providers.Web3Provider(provider).getSigner(account);
+  }
+
+  async isAuthorized() {
+    try {
+      const account = await this.getAccount();
+      return !!account;
+    } catch {
+      return false;
+    }
+  }
+
+}
+
+async function _switchChain2(chainId) {
+  const provider = await this.getProvider();
+  const id = hexValue(chainId);
+
+  try {
+    var _this$chains$find;
+
+    await provider.request({
+      method: 'wallet_switchEthereumChain',
+      params: [{
+        chainId: id
+      }]
+    });
+    return (_this$chains$find = this.chains.find(x => x.id === chainId)) !== null && _this$chains$find !== void 0 ? _this$chains$find : {
+      id: chainId,
+      name: "Chain ".concat(id),
+      network: "".concat(id),
+      rpcUrls: {
+        default: ''
+      }
+    };
+  } catch (error) {
+    const message = typeof error === 'string' ? error : error === null || error === void 0 ? void 0 : error.message;
+    if (/user rejected request/i.test(message)) throw new UserRejectedRequestError(error);
+    throw new SwitchChainError(error);
+  }
+}
+
+export { WalletConnectConnector };

package/connectors/walletConnect/package.json

@@ -0,0 +1,3 @@
+{
+  "main": "dist/wagmi-core-connectors-walletConnect.esm.js"
+}