@wagmi/connectors 0.3.23 → 0.3.24

package/dist/coinbaseWallet.js

@@ -0,0 +1,216 @@
+import {
+  Connector,
+  __privateAdd,
+  __privateGet,
+  __privateMethod,
+  __privateSet,
+  __publicField
+} from "./chunk-5NCTPR6C.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.http[0];
+      __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}`,
+        nativeCurrency: { name: "Ether", decimals: 18, symbol: "ETH" },
+        rpcUrls: { default: { http: [""] }, public: { http: [""] } }
+      };
+    } 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?.http[0] ?? ""],
+                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

@@ -1 +1,166 @@
-export * from '../src/index'
+export { C as Connector, a as ConnectorData, b as ConnectorEvents } from './base-84a689bb.js';
+import { Address, ResolvedConfig } from 'abitype';
+import '@wagmi/core';
+import '@wagmi/core/chains';
+import 'eventemitter3';
+
+type AddEthereumChainParameter = {
+    /** A 0x-prefixed hexadecimal string */
+    chainId: string;
+    chainName: string;
+    nativeCurrency?: {
+        name: string;
+        /** 2-6 characters long */
+        symbol: string;
+        decimals: number;
+    };
+    rpcUrls: string[];
+    blockExplorerUrls?: string[];
+    /** Currently ignored. */
+    iconUrls?: string[];
+};
+type WalletPermissionCaveat = {
+    type: string;
+    value: any;
+};
+type WalletPermission = {
+    caveats: WalletPermissionCaveat[];
+    date: number;
+    id: string;
+    invoker: `http://${string}` | `https://${string}`;
+    parentCapability: 'eth_accounts' | string;
+};
+type WatchAssetParams = {
+    /** In the future, other standards will be supported */
+    type: 'ERC20';
+    options: {
+        /** Address of token contract */
+        address: Address;
+        /** Number of token decimals */
+        decimals: ResolvedConfig['IntType'];
+        /** String url of token logo */
+        image?: string;
+        /** A ticker symbol or shorthand, up to 5 characters */
+        symbol: string;
+    };
+};
+type InjectedProviderFlags = {
+    isApexWallet?: true;
+    isAvalanche?: true;
+    isBackpack?: true;
+    isBifrost?: true;
+    isBitKeep?: true;
+    isBitski?: true;
+    isBlockWallet?: true;
+    isBraveWallet?: true;
+    isCoinbaseWallet?: true;
+    isDawn?: true;
+    isEnkrypt?: true;
+    isExodus?: true;
+    isFrame?: true;
+    isFrontier?: true;
+    isGamestop?: true;
+    isHyperPay?: true;
+    isImToken?: true;
+    isKuCoinWallet?: true;
+    isMathWallet?: true;
+    isMetaMask?: true;
+    isOkxWallet?: true;
+    isOKExWallet?: true;
+    isOneInchAndroidWallet?: true;
+    isOneInchIOSWallet?: true;
+    isOpera?: true;
+    isPhantom?: true;
+    isPortal?: true;
+    isRabby?: true;
+    isRainbow?: true;
+    isStatus?: true;
+    isTally?: true;
+    isTokenPocket?: true;
+    isTokenary?: true;
+    isTrust?: true;
+    isTrustWallet?: true;
+    isXDEFI?: true;
+    isZerion?: true;
+};
+type InjectedProviders = InjectedProviderFlags & {
+    isMetaMask: true;
+    /** Only exists in MetaMask as of 2022/04/03 */
+    _events: {
+        connect?: () => void;
+    };
+    /** Only exists in MetaMask as of 2022/04/03 */
+    _state?: {
+        accounts?: string[];
+        initialized?: boolean;
+        isConnected?: boolean;
+        isPermanentlyDisconnected?: boolean;
+        isUnlocked?: boolean;
+    };
+};
+interface Ethereum extends InjectedProviders {
+    on?: (...args: any[]) => void;
+    removeListener?: (...args: any[]) => void;
+    providers?: Ethereum[];
+    /**
+     * EIP-747: Add wallet_watchAsset to Provider
+     * https://eips.ethereum.org/EIPS/eip-747
+     */
+    request(args: {
+        method: 'wallet_watchAsset';
+        params: WatchAssetParams;
+    }): Promise<boolean>;
+    /**
+     * EIP-1193: Ethereum Provider JavaScript API
+     * https://eips.ethereum.org/EIPS/eip-1193
+     */
+    request(args: {
+        method: 'eth_accounts';
+    }): Promise<Address[]>;
+    request(args: {
+        method: 'eth_chainId';
+    }): Promise<string>;
+    request(args: {
+        method: 'eth_requestAccounts';
+    }): Promise<Address[]>;
+    /**
+     * EIP-1474: Remote procedure call specification
+     * https://eips.ethereum.org/EIPS/eip-1474
+     */
+    request(args: {
+        method: 'web3_clientVersion';
+    }): Promise<string>;
+    /**
+     * EIP-2255: Wallet Permissions System
+     * https://eips.ethereum.org/EIPS/eip-2255
+     */
+    request(args: {
+        method: 'wallet_requestPermissions';
+        params: [{
+            eth_accounts: Record<string, any>;
+        }];
+    }): Promise<WalletPermission[]>;
+    request(args: {
+        method: 'wallet_getPermissions';
+    }): Promise<WalletPermission[]>;
+    /**
+     * EIP-3085: Wallet Add Ethereum Chain RPC Method
+     * https://eips.ethereum.org/EIPS/eip-3085
+     */
+    request(args: {
+        method: 'wallet_addEthereumChain';
+        params: AddEthereumChainParameter[];
+    }): Promise<null>;
+    /**
+     * EIP-3326: Wallet Switch Ethereum Chain RPC Method
+     * https://eips.ethereum.org/EIPS/eip-3326
+     */
+    request(args: {
+        method: 'wallet_switchEthereumChain';
+        params: [{
+            chainId: string;
+        }];
+    }): Promise<null>;
+}
+
+export { Ethereum };

package/dist/index.js

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

package/dist/injected.d.ts

@@ -1 +1,68 @@
-export * from '../src/injected'
+import { Address } from '@wagmi/core';
+import { Chain } from '@wagmi/core/chains';
+import { providers } from 'ethers';
+import { C as Connector } from './base-84a689bb.js';
+import { Ethereum } from './index.js';
+import 'eventemitter3';
+import 'abitype';
+
+type InjectedConnectorOptions = {
+    /** Name of connector */
+    name?: string | ((detectedName: string | string[]) => string);
+    /**
+     * [EIP-1193](https://eips.ethereum.org/EIPS/eip-1193) Ethereum Provider to target
+     *
+     * @default
+     * () => typeof window !== 'undefined' ? window.ethereum : undefined
+     */
+    getProvider?: () => Ethereum | undefined;
+    /**
+     * MetaMask and other injected providers do not support programmatic disconnect.
+     * This flag simulates the disconnect behavior by keeping track of connection status in storage. See [GitHub issue](https://github.com/MetaMask/metamask-extension/issues/10353) for more info.
+     * @default true
+     */
+    shimDisconnect?: boolean;
+};
+type ConnectorOptions = InjectedConnectorOptions & Required<Pick<InjectedConnectorOptions, 'getProvider'>>;
+declare class InjectedConnector extends Connector<Ethereum | undefined, ConnectorOptions, providers.JsonRpcSigner> {
+    #private;
+    readonly id: string;
+    readonly name: string;
+    readonly ready: boolean;
+    protected shimDisconnectKey: string;
+    constructor({ chains, options: options_, }?: {
+        chains?: Chain[];
+        options?: InjectedConnectorOptions;
+    });
+    connect({ chainId }?: {
+        chainId?: number;
+    }): Promise<{
+        account: `0x${string}`;
+        chain: {
+            id: number;
+            unsupported: boolean;
+        };
+        provider: Ethereum;
+    }>;
+    disconnect(): Promise<void>;
+    getAccount(): Promise<`0x${string}`>;
+    getChainId(): Promise<number>;
+    getProvider(): Promise<Ethereum | undefined>;
+    getSigner({ chainId }?: {
+        chainId?: number;
+    }): Promise<providers.JsonRpcSigner>;
+    isAuthorized(): Promise<boolean>;
+    switchChain(chainId: number): Promise<Chain>;
+    watchAsset({ address, decimals, image, symbol, }: {
+        address: Address;
+        decimals?: number;
+        image?: string;
+        symbol: string;
+    }): Promise<boolean>;
+    protected onAccountsChanged: (accounts: string[]) => void;
+    protected onChainChanged: (chainId: number | string) => void;
+    protected onDisconnect: (error: Error) => Promise<void>;
+    protected isUserRejectedRequestError(error: unknown): boolean;
+}
+
+export { InjectedConnector, InjectedConnectorOptions };

package/dist/injected.js

@@ -0,0 +1,7 @@
+import {
+  InjectedConnector
+} from "./chunk-2VZS2JHJ.js";
+import "./chunk-5NCTPR6C.js";
+export {
+  InjectedConnector
+};

package/dist/ledger.d.ts

@@ -1 +1,43 @@
-export * from '../src/ledger'
+import { EthereumProvider } from '@ledgerhq/connect-kit-loader';
+import { Chain } from '@wagmi/core';
+import { providers } from 'ethers';
+import { C as Connector, a as ConnectorData } from './base-84a689bb.js';
+import '@wagmi/core/chains';
+import 'eventemitter3';
+
+type LedgerConnectorOptions = {
+    bridge?: string;
+    chainId?: number;
+    enableDebugLogs?: boolean;
+    rpc?: {
+        [chainId: number]: string;
+    };
+};
+type LedgerSigner = providers.JsonRpcSigner;
+declare class LedgerConnector extends Connector<EthereumProvider, LedgerConnectorOptions, LedgerSigner> {
+    #private;
+    readonly id = "ledger";
+    readonly name = "Ledger";
+    readonly ready = true;
+    constructor({ chains, options, }?: {
+        chains?: Chain[];
+        options?: LedgerConnectorOptions;
+    });
+    connect(): Promise<Required<ConnectorData>>;
+    disconnect(): Promise<void>;
+    getAccount(): Promise<`0x${string}`>;
+    getChainId(): Promise<number>;
+    getProvider({ chainId, create }?: {
+        chainId?: number;
+        create?: boolean;
+    }): Promise<EthereumProvider>;
+    getSigner({ chainId }?: {
+        chainId?: number;
+    }): Promise<providers.JsonRpcSigner>;
+    isAuthorized(): Promise<boolean>;
+    protected onAccountsChanged: (accounts: string[]) => void;
+    protected onChainChanged: (chainId: number | string) => void;
+    protected onDisconnect: () => void;
+}
+
+export { LedgerConnector };

package/dist/ledger.js

@@ -0,0 +1,187 @@
+import {
+  Connector,
+  __privateAdd,
+  __privateGet,
+  __privateMethod,
+  __privateSet,
+  __publicField
+} from "./chunk-5NCTPR6C.js";
+
+// src/ledger.ts
+import {
+  SupportedProviders,
+  loadConnectKit
+} from "@ledgerhq/connect-kit-loader";
+import {
+  SwitchChainError,
+  UserRejectedRequestError,
+  normalizeChainId
+} from "@wagmi/core";
+import { providers } from "ethers";
+import { getAddress, hexValue } from "ethers/lib/utils.js";
+var _provider, _switchChain, switchChain_fn;
+var LedgerConnector = class extends Connector {
+  constructor({
+    chains,
+    options = { enableDebugLogs: false }
+  } = {}) {
+    super({ chains, options });
+    __privateAdd(this, _switchChain);
+    __publicField(this, "id", "ledger");
+    __publicField(this, "name", "Ledger");
+    __publicField(this, "ready", true);
+    __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() {
+    try {
+      const provider = await this.getProvider({ create: true });
+      if (provider.on) {
+        provider.on("accountsChanged", this.onAccountsChanged);
+        provider.on("chainChanged", this.onChainChanged);
+        provider.on("disconnect", this.onDisconnect);
+      }
+      this.emit("message", { type: "connecting" });
+      const accounts = await provider.request({
+        method: "eth_requestAccounts"
+      });
+      const account = getAddress(accounts[0]);
+      const id = await this.getChainId();
+      const unsupported = this.isChainUnsupported(id);
+      this.switchChain = __privateMethod(this, _switchChain, switchChain_fn);
+      return {
+        account,
+        chain: { id, unsupported },
+        provider: new providers.Web3Provider(
+          provider
+        )
+      };
+    } catch (error) {
+      if (error.code === 4001) {
+        throw new UserRejectedRequestError(error);
+      }
+      if (error.code === -32002) {
+        throw error instanceof Error ? error : new Error(String(error));
+      }
+      throw error;
+    }
+  }
+  async disconnect() {
+    const provider = await this.getProvider();
+    if (provider?.disconnect) {
+      await provider.disconnect();
+    }
+    if (provider?.removeListener) {
+      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 = await provider.request({
+      method: "eth_accounts"
+    });
+    const account = getAddress(accounts[0]);
+    return account;
+  }
+  async getChainId() {
+    const provider = await this.getProvider();
+    const chainId = await provider.request({
+      method: "eth_chainId"
+    });
+    return normalizeChainId(chainId);
+  }
+  async getProvider({ chainId, create } = {
+    create: false
+  }) {
+    if (!__privateGet(this, _provider) || chainId || create) {
+      const connectKit = await loadConnectKit();
+      if (this.options.enableDebugLogs) {
+        connectKit.enableDebugLogs();
+      }
+      const rpc = this.chains.reduce(
+        (rpc2, chain) => ({
+          ...rpc2,
+          [chain.id]: chain.rpcUrls.default.http[0]
+        }),
+        {}
+      );
+      connectKit.checkSupport({
+        bridge: this.options.bridge,
+        providerType: SupportedProviders.Ethereum,
+        chainId: chainId || this.options.chainId,
+        rpc: { ...rpc, ...this.options?.rpc }
+      });
+      __privateSet(this, _provider, await connectKit.getProvider());
+    }
+    return __privateGet(this, _provider);
+  }
+  async getSigner({ chainId } = {}) {
+    const [provider, account] = await Promise.all([
+      this.getProvider({ chainId }),
+      this.getAccount()
+    ]);
+    return new providers.Web3Provider(
+      provider,
+      chainId
+    ).getSigner(account);
+  }
+  async isAuthorized() {
+    try {
+      const account = await this.getAccount();
+      return !!account;
+    } catch {
+      return false;
+    }
+  }
+};
+_provider = new WeakMap();
+_switchChain = new WeakSet();
+switchChain_fn = async function(chainId) {
+  const provider = await this.getProvider();
+  const id = hexValue(chainId);
+  try {
+    await Promise.race([
+      provider.request({
+        method: "wallet_switchEthereumChain",
+        params: [{ chainId: id }]
+      }),
+      new Promise(
+        (res) => this.on("change", ({ chain }) => {
+          if (chain?.id === chainId)
+            res(chainId);
+        })
+      )
+    ]);
+    return this.chains.find((x) => x.id === chainId) ?? {
+      id: chainId,
+      name: `Chain ${id}`,
+      network: `${id}`,
+      nativeCurrency: { name: "Ether", decimals: 18, symbol: "ETH" },
+      rpcUrls: { default: { http: [""] }, public: { http: [""] } }
+    };
+  } catch (error) {
+    const message = typeof error === "string" ? error : error?.message;
+    if (/user rejected request/i.test(message))
+      throw new UserRejectedRequestError(error);
+    throw new SwitchChainError(error);
+  }
+};
+export {
+  LedgerConnector
+};