@wagmi/connectors 1.0.0-next.4 → 1.0.0-next.6

package/dist/ledger.js

@@ -0,0 +1,192 @@
+import {
+  normalizeChainId
+} from "./chunk-OQILYQDO.js";
+import {
+  Connector,
+  __privateAdd,
+  __privateGet,
+  __privateMethod,
+  __privateSet,
+  __publicField
+} from "./chunk-QYMCVNHT.js";
+
+// src/ledger.ts
+import {
+  SupportedProviders,
+  loadConnectKit
+} from "@ledgerhq/connect-kit-loader";
+import {
+  SwitchChainError,
+  UserRejectedRequestError,
+  createWalletClient,
+  custom,
+  getAddress,
+  numberToHex
+} from "viem";
+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 }
+      };
+    } 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 getWalletClient({ chainId } = {}) {
+    const [provider, account] = await Promise.all([
+      this.getProvider({ chainId }),
+      this.getAccount()
+    ]);
+    const chain = this.chains.find((x) => x.id === chainId) || this.chains[0];
+    if (!provider)
+      throw new Error("provider is required.");
+    return createWalletClient({
+      account,
+      chain,
+      transport: custom(provider)
+    });
+  }
+  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 = numberToHex(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
+};

package/dist/metaMask.d.ts

@@ -1 +1,37 @@
-export * from '../src/metaMask'
+import { Chain } from '@wagmi/chains';
+import { InjectedConnectorOptions, InjectedConnector } from './injected.js';
+import { W as WindowProvider } from './base-a11da01a.js';
+import 'abitype/dist/abi-7aa1f183';
+import 'viem/dist/types/types/eip1193';
+import 'viem/dist/types/types';
+import 'viem';
+import 'abitype';
+import 'eventemitter3';
+
+type MetaMaskConnectorOptions = Pick<InjectedConnectorOptions, 'shimDisconnect'> & {
+    /**
+     * While "disconnected" with `shimDisconnect`, allows user to select a different MetaMask account (than the currently connected account) when trying to connect.
+     */
+    UNSTABLE_shimOnConnectSelectAccount?: boolean;
+};
+declare class MetaMaskConnector extends InjectedConnector {
+    #private;
+    readonly id = "metaMask";
+    protected shimDisconnectKey: string;
+    constructor({ chains, options: options_, }?: {
+        chains?: Chain[];
+        options?: MetaMaskConnectorOptions;
+    });
+    connect({ chainId }?: {
+        chainId?: number;
+    }): Promise<{
+        account: `0x${string}`;
+        chain: {
+            id: number;
+            unsupported: boolean;
+        };
+        provider: WindowProvider;
+    }>;
+}
+
+export { MetaMaskConnector, MetaMaskConnectorOptions };

package/dist/metaMask.js

@@ -0,0 +1,139 @@
+import {
+  InjectedConnector
+} from "./chunk-K4TVWOJP.js";
+import {
+  ConnectorNotFoundError
+} from "./chunk-ZCAPXGBX.js";
+import "./chunk-OQILYQDO.js";
+import {
+  __privateAdd,
+  __privateGet,
+  __privateSet,
+  __publicField
+} from "./chunk-QYMCVNHT.js";
+
+// src/metaMask.ts
+import {
+  ResourceNotFoundRpcError,
+  UserRejectedRequestError,
+  getAddress
+} from "viem";
+var _UNSTABLE_shimOnConnectSelectAccount;
+var MetaMaskConnector = class extends InjectedConnector {
+  constructor({
+    chains,
+    options: options_
+  } = {}) {
+    const options = {
+      name: "MetaMask",
+      shimDisconnect: true,
+      getProvider() {
+        function getReady(ethereum2) {
+          const isMetaMask = !!ethereum2?.isMetaMask;
+          if (!isMetaMask)
+            return;
+          if (ethereum2.isBraveWallet && !ethereum2._events && !ethereum2._state)
+            return;
+          if (ethereum2.isApexWallet)
+            return;
+          if (ethereum2.isAvalanche)
+            return;
+          if (ethereum2.isBitKeep)
+            return;
+          if (ethereum2.isBlockWallet)
+            return;
+          if (ethereum2.isKuCoinWallet)
+            return;
+          if (ethereum2.isMathWallet)
+            return;
+          if (ethereum2.isOkxWallet || ethereum2.isOKExWallet)
+            return;
+          if (ethereum2.isOneInchIOSWallet || ethereum2.isOneInchAndroidWallet)
+            return;
+          if (ethereum2.isOpera)
+            return;
+          if (ethereum2.isPortal)
+            return;
+          if (ethereum2.isRabby)
+            return;
+          if (ethereum2.isTokenPocket)
+            return;
+          if (ethereum2.isTokenary)
+            return;
+          if (ethereum2.isZerion)
+            return;
+          return ethereum2;
+        }
+        if (typeof window === "undefined")
+          return;
+        const ethereum = window.ethereum;
+        if (ethereum?.providers)
+          return ethereum.providers.find(getReady);
+        return getReady(ethereum);
+      },
+      ...options_
+    };
+    super({ chains, options });
+    __publicField(this, "id", "metaMask");
+    __publicField(this, "shimDisconnectKey", `${this.id}.shimDisconnect`);
+    __privateAdd(this, _UNSTABLE_shimOnConnectSelectAccount, void 0);
+    __privateSet(this, _UNSTABLE_shimOnConnectSelectAccount, options.UNSTABLE_shimOnConnectSelectAccount);
+  }
+  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" });
+      let account = null;
+      if (__privateGet(this, _UNSTABLE_shimOnConnectSelectAccount) && this.options?.shimDisconnect && !this.storage?.getItem(this.shimDisconnectKey)) {
+        account = await this.getAccount().catch(() => null);
+        const isConnected = !!account;
+        if (isConnected)
+          try {
+            await provider.request({
+              method: "wallet_requestPermissions",
+              params: [{ eth_accounts: {} }]
+            });
+            account = await this.getAccount();
+          } catch (error) {
+            if (this.isUserRejectedRequestError(error))
+              throw new UserRejectedRequestError(error);
+            if (error.code === new ResourceNotFoundRpcError(error).code)
+              throw error;
+          }
+      }
+      if (!account) {
+        const accounts = await provider.request({
+          method: "eth_requestAccounts"
+        });
+        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);
+      }
+      if (this.options?.shimDisconnect)
+        this.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 ResourceNotFoundRpcError(error);
+      throw error;
+    }
+  }
+};
+_UNSTABLE_shimOnConnectSelectAccount = new WeakMap();
+export {
+  MetaMaskConnector
+};