@wagmi/connectors 0.0.0-20221114055155

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2022 wagmi inc.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/base-66b49041.d.ts

@@ -0,0 +1,64 @@
+import { Chain, Address } from '@wagmi/core';
+import EventEmitter from 'eventemitter3';
+
+declare type ConnectorData<Provider = any> = {
+    account?: `0x${string}`;
+    chain?: {
+        id: number;
+        unsupported: boolean;
+    };
+    provider?: Provider;
+};
+interface ConnectorEvents<Provider = any> {
+    change(data: ConnectorData<Provider>): void;
+    connect(data: ConnectorData<Provider>): void;
+    message({ type, data }: {
+        type: string;
+        data?: unknown;
+    }): void;
+    disconnect(): void;
+    error(error: Error): void;
+}
+declare abstract class Connector<Provider = any, Options = any, Signer = any> extends EventEmitter<ConnectorEvents<Provider>> {
+    /** Unique connector id */
+    abstract readonly id: string;
+    /** Connector name */
+    abstract readonly name: string;
+    /** Chains connector supports */
+    readonly chains: Chain[];
+    /** Options to use with connector */
+    readonly options: Options;
+    /** Whether connector is usable */
+    abstract readonly ready: boolean;
+    constructor({ chains, options, }: {
+        chains?: Chain[];
+        options: Options;
+    });
+    abstract connect(config?: {
+        chainId?: number;
+    }): Promise<Required<ConnectorData>>;
+    abstract disconnect(): Promise<void>;
+    abstract getAccount(): Promise<Address>;
+    abstract getChainId(): Promise<number>;
+    abstract getProvider(config?: {
+        chainId?: number;
+    }): Promise<Provider>;
+    abstract getSigner(config?: {
+        chainId?: number;
+    }): Promise<Signer>;
+    abstract isAuthorized(): Promise<boolean>;
+    switchChain?(chainId: number): Promise<Chain>;
+    watchAsset?(asset: {
+        address: string;
+        decimals?: number;
+        image?: string;
+        symbol: string;
+    }): Promise<boolean>;
+    protected abstract onAccountsChanged(accounts: Address[]): void;
+    protected abstract onChainChanged(chain: number | string): void;
+    protected abstract onDisconnect(error: Error): void;
+    protected getBlockExplorerUrls(chain: Chain): string[];
+    protected isChainUnsupported(chainId: number): boolean;
+}
+
+export { Connector as C, ConnectorData as a, ConnectorEvents as b };

package/dist/chunk-QCF44MXG.js

@@ -0,0 +1,242 @@
+import {
+  Connector,
+  __privateAdd,
+  __privateGet,
+  __privateSet,
+  __publicField
+} from "./chunk-QQDVTXYM.js";
+
+// src/injected.ts
+import {
+  AddChainError,
+  ChainNotConfiguredError,
+  ConnectorNotFoundError,
+  ResourceUnavailableError,
+  SwitchChainError,
+  UserRejectedRequestError,
+  getClient,
+  normalizeChainId
+} from "@wagmi/core";
+import { getInjectedName } from "@wagmi/core/utils";
+import { providers } from "ethers";
+import { getAddress, hexValue } from "ethers/lib/utils.js";
+var _provider, _switchingChains;
+var InjectedConnector = class extends Connector {
+  constructor({
+    chains,
+    options: options_
+  } = {}) {
+    const options = {
+      shimDisconnect: true,
+      shimChainChangedDisconnect: true,
+      ...options_
+    };
+    super({ chains, options });
+    __publicField(this, "id");
+    __publicField(this, "name");
+    __publicField(this, "ready", typeof window != "undefined" && !!window.ethereum);
+    __privateAdd(this, _provider, void 0);
+    __privateAdd(this, _switchingChains, void 0);
+    __publicField(this, "shimDisconnectKey", "injected.shimDisconnect");
+    __publicField(this, "onAccountsChanged", (accounts) => {
+      if (accounts.length === 0)
+        this.emit("disconnect");
+      else
+        this.emit("change", {
+          account: getAddress(accounts[0])
+        });
+    });
+    __publicField(this, "onChainChanged", (chainId) => {
+      const id = normalizeChainId(chainId);
+      const unsupported = this.isChainUnsupported(id);
+      this.emit("change", { chain: { id, unsupported } });
+    });
+    __publicField(this, "onDisconnect", () => {
+      if (this.options?.shimChainChangedDisconnect && __privateGet(this, _switchingChains)) {
+        __privateSet(this, _switchingChains, false);
+        return;
+      }
+      this.emit("disconnect");
+      if (this.options?.shimDisconnect)
+        getClient().storage?.removeItem(this.shimDisconnectKey);
+    });
+    let name = "Injected";
+    const overrideName = options.name;
+    if (typeof overrideName === "string")
+      name = overrideName;
+    else if (typeof window !== "undefined") {
+      const detectedName = getInjectedName(window.ethereum);
+      if (overrideName)
+        name = overrideName(detectedName);
+      else
+        name = typeof detectedName === "string" ? detectedName : detectedName[0];
+    }
+    this.id = "injected";
+    this.name = name;
+  }
+  async connect({ chainId } = {}) {
+    try {
+      const provider = await this.getProvider();
+      if (!provider)
+        throw new ConnectorNotFoundError();
+      if (provider.on) {
+        provider.on("accountsChanged", this.onAccountsChanged);
+        provider.on("chainChanged", this.onChainChanged);
+        provider.on("disconnect", this.onDisconnect);
+      }
+      this.emit("message", { type: "connecting" });
+      const account = await this.getAccount();
+      let id = await this.getChainId();
+      let unsupported = this.isChainUnsupported(id);
+      if (chainId && id !== chainId) {
+        const chain = await this.switchChain(chainId);
+        id = chain.id;
+        unsupported = this.isChainUnsupported(id);
+      }
+      if (this.options?.shimDisconnect)
+        getClient().storage?.setItem(this.shimDisconnectKey, true);
+      return { account, chain: { id, unsupported }, provider };
+    } catch (error) {
+      if (this.isUserRejectedRequestError(error))
+        throw new UserRejectedRequestError(error);
+      if (error.code === -32002)
+        throw new ResourceUnavailableError(error);
+      throw error;
+    }
+  }
+  async disconnect() {
+    const provider = await this.getProvider();
+    if (!provider?.removeListener)
+      return;
+    provider.removeListener("accountsChanged", this.onAccountsChanged);
+    provider.removeListener("chainChanged", this.onChainChanged);
+    provider.removeListener("disconnect", this.onDisconnect);
+    if (this.options?.shimDisconnect)
+      getClient().storage?.removeItem(this.shimDisconnectKey);
+  }
+  async getAccount() {
+    const provider = await this.getProvider();
+    if (!provider)
+      throw new ConnectorNotFoundError();
+    const accounts = await provider.request({
+      method: "eth_requestAccounts"
+    });
+    return getAddress(accounts[0]);
+  }
+  async getChainId() {
+    const provider = await this.getProvider();
+    if (!provider)
+      throw new ConnectorNotFoundError();
+    return provider.request({ method: "eth_chainId" }).then(normalizeChainId);
+  }
+  async getProvider() {
+    if (typeof window !== "undefined" && !!window.ethereum)
+      __privateSet(this, _provider, window.ethereum);
+    return __privateGet(this, _provider);
+  }
+  async getSigner({ chainId } = {}) {
+    const [provider, account] = await Promise.all([
+      this.getProvider(),
+      this.getAccount()
+    ]);
+    return new providers.Web3Provider(
+      provider,
+      chainId
+    ).getSigner(account);
+  }
+  async isAuthorized() {
+    try {
+      if (this.options?.shimDisconnect && !getClient().storage?.getItem(this.shimDisconnectKey))
+        return false;
+      const provider = await this.getProvider();
+      if (!provider)
+        throw new ConnectorNotFoundError();
+      const accounts = await provider.request({
+        method: "eth_accounts"
+      });
+      const account = accounts[0];
+      return !!account;
+    } catch {
+      return false;
+    }
+  }
+  async switchChain(chainId) {
+    if (this.options?.shimChainChangedDisconnect)
+      __privateSet(this, _switchingChains, true);
+    const provider = await this.getProvider();
+    if (!provider)
+      throw new ConnectorNotFoundError();
+    const id = hexValue(chainId);
+    try {
+      await provider.request({
+        method: "wallet_switchEthereumChain",
+        params: [{ chainId: id }]
+      });
+      return this.chains.find((x) => x.id === chainId) ?? {
+        id: chainId,
+        name: `Chain ${id}`,
+        network: `${id}`,
+        rpcUrls: { default: "" }
+      };
+    } catch (error) {
+      const chain = this.chains.find((x) => x.id === chainId);
+      if (!chain)
+        throw new ChainNotConfiguredError({ chainId, connectorId: this.id });
+      if (error.code === 4902 || error?.data?.originalError?.code === 4902) {
+        try {
+          await provider.request({
+            method: "wallet_addEthereumChain",
+            params: [
+              {
+                chainId: id,
+                chainName: chain.name,
+                nativeCurrency: chain.nativeCurrency,
+                rpcUrls: [chain.rpcUrls.public ?? chain.rpcUrls.default],
+                blockExplorerUrls: this.getBlockExplorerUrls(chain)
+              }
+            ]
+          });
+          return chain;
+        } catch (addError) {
+          if (this.isUserRejectedRequestError(addError))
+            throw new UserRejectedRequestError(error);
+          throw new AddChainError();
+        }
+      }
+      if (this.isUserRejectedRequestError(error))
+        throw new UserRejectedRequestError(error);
+      throw new SwitchChainError(error);
+    }
+  }
+  async watchAsset({
+    address,
+    decimals = 18,
+    image,
+    symbol
+  }) {
+    const provider = await this.getProvider();
+    if (!provider)
+      throw new ConnectorNotFoundError();
+    return provider.request({
+      method: "wallet_watchAsset",
+      params: {
+        type: "ERC20",
+        options: {
+          address,
+          decimals,
+          image,
+          symbol
+        }
+      }
+    });
+  }
+  isUserRejectedRequestError(error) {
+    return error.code === 4001;
+  }
+};
+_provider = new WeakMap();
+_switchingChains = new WeakMap();
+
+export {
+  InjectedConnector
+};

package/dist/chunk-QQDVTXYM.js

@@ -0,0 +1,65 @@
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => {
+  __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
+};
+var __accessCheck = (obj, member, msg) => {
+  if (!member.has(obj))
+    throw TypeError("Cannot " + msg);
+};
+var __privateGet = (obj, member, getter) => {
+  __accessCheck(obj, member, "read from private field");
+  return getter ? getter.call(obj) : member.get(obj);
+};
+var __privateAdd = (obj, member, value) => {
+  if (member.has(obj))
+    throw TypeError("Cannot add the same private member more than once");
+  member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
+};
+var __privateSet = (obj, member, value, setter) => {
+  __accessCheck(obj, member, "write to private field");
+  setter ? setter.call(obj, value) : member.set(obj, value);
+  return value;
+};
+var __privateMethod = (obj, member, method) => {
+  __accessCheck(obj, member, "access private method");
+  return method;
+};
+
+// src/base.ts
+import { defaultChains } from "@wagmi/core";
+import { default as EventEmitter } from "eventemitter3";
+var Connector = class extends EventEmitter {
+  constructor({
+    chains = defaultChains,
+    options
+  }) {
+    super();
+    __publicField(this, "chains");
+    __publicField(this, "options");
+    this.chains = chains;
+    this.options = options;
+  }
+  getBlockExplorerUrls(chain) {
+    const { default: blockExplorer, ...blockExplorers } = chain.blockExplorers ?? {};
+    if (blockExplorer)
+      return [
+        blockExplorer.url,
+        ...Object.values(blockExplorers).map((x) => x.url)
+      ];
+    return [];
+  }
+  isChainUnsupported(chainId) {
+    return !this.chains.some((x) => x.id === chainId);
+  }
+};
+
+export {
+  __publicField,
+  __privateGet,
+  __privateAdd,
+  __privateSet,
+  __privateMethod,
+  Connector
+};

package/dist/coinbaseWallet.d.ts

@@ -0,0 +1,59 @@
+import { CoinbaseWalletProvider } from '@coinbase/wallet-sdk';
+import { CoinbaseWalletSDKOptions } from '@coinbase/wallet-sdk/dist/CoinbaseWalletSDK';
+import { Chain } from '@wagmi/core';
+import { providers } from 'ethers';
+import { C as Connector } from './base-66b49041.js';
+import 'eventemitter3';
+
+declare type Options = CoinbaseWalletSDKOptions & {
+    /**
+     * Fallback Ethereum JSON RPC URL
+     * @default ""
+     */
+    jsonRpcUrl?: string;
+    /**
+     * Fallback Ethereum Chain ID
+     * @default 1
+     */
+    chainId?: number;
+};
+declare class CoinbaseWalletConnector extends Connector<CoinbaseWalletProvider, Options, providers.JsonRpcSigner> {
+    #private;
+    readonly id = "coinbaseWallet";
+    readonly name = "Coinbase Wallet";
+    readonly ready = true;
+    constructor({ chains, options }: {
+        chains?: Chain[];
+        options: Options;
+    });
+    connect({ chainId }?: {
+        chainId?: number;
+    }): Promise<{
+        account: `0x${string}`;
+        chain: {
+            id: number;
+            unsupported: boolean;
+        };
+        provider: providers.Web3Provider;
+    }>;
+    disconnect(): Promise<void>;
+    getAccount(): Promise<`0x${string}`>;
+    getChainId(): Promise<number>;
+    getProvider(): Promise<CoinbaseWalletProvider>;
+    getSigner({ chainId }?: {
+        chainId?: number;
+    }): Promise<providers.JsonRpcSigner>;
+    isAuthorized(): Promise<boolean>;
+    switchChain(chainId: number): Promise<Chain>;
+    watchAsset({ address, decimals, image, symbol, }: {
+        address: string;
+        decimals?: number;
+        image?: string;
+        symbol: string;
+    }): Promise<boolean>;
+    protected onAccountsChanged: (accounts: string[]) => void;
+    protected onChainChanged: (chainId: number | string) => void;
+    protected onDisconnect: () => void;
+}
+
+export { CoinbaseWalletConnector };

package/dist/coinbaseWallet.js

@@ -0,0 +1,215 @@
+import {
+  Connector,
+  __privateAdd,
+  __privateGet,
+  __privateMethod,
+  __privateSet,
+  __publicField
+} from "./chunk-QQDVTXYM.js";
+
+// src/coinbaseWallet.ts
+import {
+  AddChainError,
+  ChainNotConfiguredError,
+  SwitchChainError,
+  UserRejectedRequestError,
+  normalizeChainId
+} from "@wagmi/core";
+import { providers } from "ethers";
+import { getAddress, hexValue } from "ethers/lib/utils.js";
+var _client, _provider, _isUserRejectedRequestError, isUserRejectedRequestError_fn;
+var CoinbaseWalletConnector = class extends Connector {
+  constructor({ chains, options }) {
+    super({
+      chains,
+      options: {
+        reloadOnDisconnect: false,
+        ...options
+      }
+    });
+    __privateAdd(this, _isUserRejectedRequestError);
+    __publicField(this, "id", "coinbaseWallet");
+    __publicField(this, "name", "Coinbase Wallet");
+    __publicField(this, "ready", true);
+    __privateAdd(this, _client, void 0);
+    __privateAdd(this, _provider, void 0);
+    __publicField(this, "onAccountsChanged", (accounts) => {
+      if (accounts.length === 0)
+        this.emit("disconnect");
+      else
+        this.emit("change", { account: getAddress(accounts[0]) });
+    });
+    __publicField(this, "onChainChanged", (chainId) => {
+      const id = normalizeChainId(chainId);
+      const unsupported = this.isChainUnsupported(id);
+      this.emit("change", { chain: { id, unsupported } });
+    });
+    __publicField(this, "onDisconnect", () => {
+      this.emit("disconnect");
+    });
+  }
+  async connect({ chainId } = {}) {
+    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]);
+      let id = await this.getChainId();
+      let unsupported = this.isChainUnsupported(id);
+      if (chainId && id !== chainId) {
+        const chain = await this.switchChain(chainId);
+        id = chain.id;
+        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(error);
+      throw error;
+    }
+  }
+  async disconnect() {
+    if (!__privateGet(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();
+  }
+  async getAccount() {
+    const provider = await this.getProvider();
+    const accounts = await provider.request({
+      method: "eth_accounts"
+    });
+    return getAddress(accounts[0]);
+  }
+  async getChainId() {
+    const provider = await this.getProvider();
+    const chainId = normalizeChainId(provider.chainId);
+    return chainId;
+  }
+  async getProvider() {
+    if (!__privateGet(this, _provider)) {
+      let CoinbaseWalletSDK = (await import("@coinbase/wallet-sdk")).default;
+      if (typeof CoinbaseWalletSDK !== "function" && typeof CoinbaseWalletSDK.default === "function")
+        CoinbaseWalletSDK = CoinbaseWalletSDK.default;
+      __privateSet(this, _client, new CoinbaseWalletSDK(this.options));
+      class WalletProvider {
+      }
+      class Client {
+      }
+      const walletExtensionChainId = __privateGet(this, _client).walletExtension?.getChainId();
+      const chain = this.chains.find(
+        (chain2) => this.options.chainId ? chain2.id === this.options.chainId : chain2.id === walletExtensionChainId
+      ) || this.chains[0];
+      const chainId = this.options.chainId || chain?.id;
+      const jsonRpcUrl = this.options.jsonRpcUrl || chain?.rpcUrls.default;
+      __privateSet(this, _provider, __privateGet(this, _client).makeWeb3Provider(jsonRpcUrl, chainId));
+    }
+    return __privateGet(this, _provider);
+  }
+  async getSigner({ chainId } = {}) {
+    const [provider, account] = await Promise.all([
+      this.getProvider(),
+      this.getAccount()
+    ]);
+    return new providers.Web3Provider(
+      provider,
+      chainId
+    ).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 {
+      await provider.request({
+        method: "wallet_switchEthereumChain",
+        params: [{ chainId: id }]
+      });
+      return this.chains.find((x) => x.id === chainId) ?? {
+        id: chainId,
+        name: `Chain ${id}`,
+        network: `${id}`,
+        rpcUrls: { default: "" }
+      };
+    } catch (error) {
+      const chain = this.chains.find((x) => x.id === chainId);
+      if (!chain)
+        throw new ChainNotConfiguredError({ chainId, connectorId: this.id });
+      if (error.code === 4902) {
+        try {
+          await provider.request({
+            method: "wallet_addEthereumChain",
+            params: [
+              {
+                chainId: id,
+                chainName: chain.name,
+                nativeCurrency: chain.nativeCurrency,
+                rpcUrls: [chain.rpcUrls.public ?? chain.rpcUrls.default],
+                blockExplorerUrls: this.getBlockExplorerUrls(chain)
+              }
+            ]
+          });
+          return chain;
+        } catch (addError) {
+          if (__privateMethod(this, _isUserRejectedRequestError, isUserRejectedRequestError_fn).call(this, addError))
+            throw new UserRejectedRequestError(addError);
+          throw new AddChainError();
+        }
+      }
+      if (__privateMethod(this, _isUserRejectedRequestError, isUserRejectedRequestError_fn).call(this, error))
+        throw new UserRejectedRequestError(error);
+      throw new SwitchChainError(error);
+    }
+  }
+  async watchAsset({
+    address,
+    decimals = 18,
+    image,
+    symbol
+  }) {
+    const provider = await this.getProvider();
+    return provider.request({
+      method: "wallet_watchAsset",
+      params: {
+        type: "ERC20",
+        options: {
+          address,
+          decimals,
+          image,
+          symbol
+        }
+      }
+    });
+  }
+};
+_client = new WeakMap();
+_provider = new WeakMap();
+_isUserRejectedRequestError = new WeakSet();
+isUserRejectedRequestError_fn = function(error) {
+  return /(user rejected)/i.test(error.message);
+};
+export {
+  CoinbaseWalletConnector
+};

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+export { C as Connector, a as ConnectorData, b as ConnectorEvents } from './base-66b49041.js';
+import '@wagmi/core';
+import 'eventemitter3';

package/dist/index.js

@@ -0,0 +1,6 @@
+import {
+  Connector
+} from "./chunk-QQDVTXYM.js";
+export {
+  Connector
+};