@wagmi/connectors 0.1.2 → 0.1.3

package/LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2022 wagmi
+Copyright (c) 2022 awkweb.eth
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

package/dist/{base-6b5431a5.d.ts → base-caae9601.d.ts}

@@ -2,7 +2,7 @@ import { Chain } from '@wagmi/core/chains';
 import { Address } from 'abitype';
 import EventEmitter from 'eventemitter3';
 
-declare type ConnectorData<Provider = any> = {
+type ConnectorData<Provider = any> = {
     account?: Address;
     chain?: {
         id: number;

package/dist/coinbaseWallet.d.ts

@@ -2,11 +2,11 @@ import { CoinbaseWalletProvider } from '@coinbase/wallet-sdk';
 import { CoinbaseWalletSDKOptions } from '@coinbase/wallet-sdk/dist/CoinbaseWalletSDK';
 import { Chain } from '@wagmi/core/chains';
 import { providers } from 'ethers';
-import { C as Connector } from './base-6b5431a5.js';
+import { C as Connector } from './base-caae9601.js';
 import 'abitype';
 import 'eventemitter3';
 
-declare type Options = CoinbaseWalletSDKOptions & {
+type Options = CoinbaseWalletSDKOptions & {
     /**
      * Fallback Ethereum JSON RPC URL
      * @default ""

package/dist/index.d.ts

@@ -1,4 +1,4 @@
-export { C as Connector, a as ConnectorData, b as ConnectorEvents } from './base-6b5431a5.js';
+export { C as Connector, a as ConnectorData, b as ConnectorEvents } from './base-caae9601.js';
 import '@wagmi/core/chains';
 import 'abitype';
 import 'eventemitter3';

package/dist/injected.d.ts

@@ -1,11 +1,11 @@
-import * as _wagmi_core_dist_index_971cda79 from '@wagmi/core/dist/index-971cda79';
+import * as _wagmi_core_dist_index_37d6352e from '@wagmi/core/dist/index-37d6352e';
 import { Chain } from '@wagmi/core/chains';
 import { Address } from 'abitype';
 import { providers } from 'ethers';
-import { C as Connector } from './base-6b5431a5.js';
+import { C as Connector } from './base-caae9601.js';
 import 'eventemitter3';
 
-declare type InjectedConnectorOptions = {
+type InjectedConnectorOptions = {
     /** Name of connector */
     name?: string | ((detectedName: string | string[]) => string);
     /**
@@ -27,7 +27,7 @@ declare type InjectedConnectorOptions = {
      */
     shimDisconnect?: boolean;
 };
-declare type ConnectorOptions = InjectedConnectorOptions & Required<Pick<InjectedConnectorOptions, 'getProvider'>>;
+type ConnectorOptions = InjectedConnectorOptions & Required<Pick<InjectedConnectorOptions, 'getProvider'>>;
 declare class InjectedConnector extends Connector<Window['ethereum'], ConnectorOptions, providers.JsonRpcSigner> {
     #private;
     readonly id: string;
@@ -46,12 +46,12 @@ declare class InjectedConnector extends Connector<Window['ethereum'], ConnectorO
             id: number;
             unsupported: boolean;
         };
-        provider: _wagmi_core_dist_index_971cda79.E;
+        provider: _wagmi_core_dist_index_37d6352e.E;
     }>;
     disconnect(): Promise<void>;
     getAccount(): Promise<`0x${string}`>;
     getChainId(): Promise<number>;
-    getProvider(): Promise<_wagmi_core_dist_index_971cda79.E | undefined>;
+    getProvider(): Promise<_wagmi_core_dist_index_37d6352e.E | undefined>;
     getSigner({ chainId }?: {
         chainId?: number;
     }): Promise<providers.JsonRpcSigner>;

package/dist/ledger.d.ts

@@ -1,12 +1,12 @@
 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-6b5431a5.js';
+import { C as Connector, a as ConnectorData } from './base-caae9601.js';
 import '@wagmi/core/chains';
 import 'abitype';
 import 'eventemitter3';
 
-declare type LedgerConnectorOptions = {
+type LedgerConnectorOptions = {
     bridge?: string;
     chainId?: number;
     enableDebugLogs?: boolean;
@@ -14,7 +14,7 @@ declare type LedgerConnectorOptions = {
         [chainId: number]: string;
     };
 };
-declare type LedgerSigner = providers.JsonRpcSigner;
+type LedgerSigner = providers.JsonRpcSigner;
 declare class LedgerConnector extends Connector<EthereumProvider, LedgerConnectorOptions, LedgerSigner> {
     #private;
     readonly id = "ledger";

package/dist/metaMask.d.ts

@@ -1,13 +1,13 @@
 import { Ethereum } from '@wagmi/core';
 import { Chain } from '@wagmi/core/chains';
 import { InjectedConnectorOptions, InjectedConnector } from './injected.js';
-import '@wagmi/core/dist/index-971cda79';
+import '@wagmi/core/dist/index-37d6352e';
 import 'abitype';
 import 'ethers';
-import './base-6b5431a5.js';
+import './base-caae9601.js';
 import 'eventemitter3';
 
-declare type MetaMaskConnectorOptions = Pick<InjectedConnectorOptions, 'shimChainChangedDisconnect' | 'shimDisconnect'> & {
+type MetaMaskConnectorOptions = Pick<InjectedConnectorOptions, 'shimChainChangedDisconnect' | 'shimDisconnect'> & {
     /**
      * While "disconnected" with `shimDisconnect`, allows user to select a different MetaMask account (than the currently connected account) when trying to connect.
      */

package/dist/mock/index.d.ts

@@ -1,12 +1,12 @@
 import * as ethers from 'ethers';
 import { providers } from 'ethers';
 import { Chain } from '@wagmi/core/chains';
-import { C as Connector, a as ConnectorData } from '../base-6b5431a5.js';
+import { C as Connector, a as ConnectorData } from '../base-caae9601.js';
 import { Signer } from '@wagmi/core';
 import EventEmitter from 'eventemitter3';
 import 'abitype';
 
-declare type MockProviderOptions = {
+type MockProviderOptions = {
     chainId: number;
     flags?: {
         isAuthorized?: boolean;
@@ -16,12 +16,12 @@ declare type MockProviderOptions = {
     };
     signer: Signer;
 };
-declare type Events = {
+type Events = {
     accountsChanged(accounts: string[]): void;
     chainChanged(chainId: number | string): void;
     disconnect(): void;
 };
-declare type Event = keyof Events;
+type Event = keyof Events;
 declare class MockProvider extends providers.BaseProvider {
     #private;
     events: EventEmitter<Events, any>;
@@ -44,7 +44,7 @@ declare class MockProvider extends providers.BaseProvider {
     toJSON(): string;
 }
 
-declare type MockConnectorOptions = Omit<MockProviderOptions, 'chainId'> & {
+type MockConnectorOptions = Omit<MockProviderOptions, 'chainId'> & {
     chainId?: number;
 };
 declare class MockConnector extends Connector<MockProvider, MockConnectorOptions> {

package/dist/walletConnect.d.ts

@@ -1,13 +1,28 @@
-import { Chain } from '@wagmi/core/chains';
+import * as _walletconnect_universal_provider from '@walletconnect/universal-provider';
+import { UniversalProvider as UniversalProvider$1, UniversalProviderOpts } from '@walletconnect/universal-provider';
+import { Chain } from '@wagmi/core';
 import WalletConnectProvider from '@walletconnect/ethereum-provider';
 import { providers } from 'ethers';
-import { C as Connector } from './base-6b5431a5.js';
+import { C as Connector } from './base-caae9601.js';
+import '@wagmi/core/chains';
 import 'abitype';
 import 'eventemitter3';
 
-declare type WalletConnectOptions = ConstructorParameters<typeof WalletConnectProvider>[0];
-declare type WalletConnectSigner = providers.JsonRpcSigner;
-declare class WalletConnectConnector extends Connector<WalletConnectProvider, WalletConnectOptions, WalletConnectSigner> {
+type UniversalProvider = InstanceType<typeof UniversalProvider$1>;
+type WalletConnectOptions = {
+    /** When `true`, uses default WalletConnect QR Code modal */
+    qrcode?: boolean;
+} & (({
+    version?: '1';
+} & ConstructorParameters<typeof WalletConnectProvider>[0]) | ({
+    /**
+     * Project ID associated with [WalletConnect account](https://cloud.walletconnect.com)
+     */
+    projectId: NonNullable<UniversalProviderOpts['projectId']>;
+    version: '2';
+} & Omit<UniversalProviderOpts, 'projectId'>));
+type WalletConnectSigner = providers.JsonRpcSigner;
+declare class WalletConnectConnector extends Connector<WalletConnectProvider | UniversalProvider, WalletConnectOptions, WalletConnectSigner> {
     #private;
     readonly id = "walletConnect";
     readonly name = "WalletConnect";
@@ -16,6 +31,7 @@ declare class WalletConnectConnector extends Connector<WalletConnectProvider, Wa
         chains?: Chain[];
         options: WalletConnectOptions;
     });
+    get version(): "1" | "2" | undefined;
     connect({ chainId }?: {
         chainId?: number;
     }): Promise<{
@@ -32,7 +48,7 @@ declare class WalletConnectConnector extends Connector<WalletConnectProvider, Wa
     getProvider({ chainId, create, }?: {
         chainId?: number;
         create?: boolean;
-    }): Promise<WalletConnectProvider>;
+    }): Promise<_walletconnect_universal_provider.default | WalletConnectProvider>;
     getSigner({ chainId }?: {
         chainId?: number;
     }): Promise<providers.JsonRpcSigner>;
@@ -40,6 +56,7 @@ declare class WalletConnectConnector extends Connector<WalletConnectProvider, Wa
     protected onAccountsChanged: (accounts: string[]) => void;
     protected onChainChanged: (chainId: number | string) => void;
     protected onDisconnect: () => void;
+    protected onDisplayUri: (uri: string) => void;
 }
 
 export { WalletConnectConnector };

package/dist/walletConnect.js

@@ -16,11 +16,22 @@ import {
 } from "@wagmi/core";
 import { providers } from "ethers";
 import { getAddress, hexValue } from "ethers/lib/utils.js";
-var switchChainAllowedRegex = /(imtoken|metamask|rainbow|trust wallet)/i;
-var _provider, _switchChain, switchChain_fn;
+var defaultV2Config = {
+  namespace: "eip155",
+  methods: [
+    "eth_sendTransaction",
+    "eth_sign",
+    "eth_signTransaction",
+    "eth_signTypedData",
+    "personal_sign"
+  ],
+  events: ["accountsChanged", "chainChanged"]
+};
+var _provider, _isChainsAuthorized, isChainsAuthorized_fn, _switchChain, switchChain_fn;
 var WalletConnectConnector = class extends Connector {
   constructor(config) {
     super(config);
+    __privateAdd(this, _isChainsAuthorized);
     __privateAdd(this, _switchChain);
     __publicField(this, "id", "walletConnect");
     __publicField(this, "name", "WalletConnect");
@@ -40,6 +51,14 @@ var WalletConnectConnector = class extends Connector {
     __publicField(this, "onDisconnect", () => {
       this.emit("disconnect");
     });
+    __publicField(this, "onDisplayUri", (uri) => {
+      this.emit("message", { type: "display_uri", data: uri });
+    });
+  }
+  get version() {
+    if ("version" in this.options)
+      return this.options.version;
+    return "1";
   }
   async connect({ chainId } = {}) {
     try {
@@ -56,13 +75,69 @@ var WalletConnectConnector = class extends Connector {
       provider.on("accountsChanged", this.onAccountsChanged);
       provider.on("chainChanged", this.onChainChanged);
       provider.on("disconnect", this.onDisconnect);
+      if (this.version === "2") {
+        provider.on("session_delete", this.onDisconnect);
+        provider.on("display_uri", this.onDisplayUri);
+        const isChainsAuthorized = await __privateMethod(this, _isChainsAuthorized, isChainsAuthorized_fn).call(this);
+        if (provider.session && !isChainsAuthorized)
+          await provider.disconnect();
+        if (!provider.session || provider.session && !isChainsAuthorized) {
+          await Promise.race([
+            provider.connect({
+              namespaces: {
+                [defaultV2Config.namespace]: {
+                  methods: defaultV2Config.methods,
+                  events: defaultV2Config.events,
+                  chains: this.chains.map(
+                    (chain) => `${defaultV2Config.namespace}:${chain.id}`
+                  ),
+                  rpcMap: this.chains.reduce(
+                    (rpc, chain) => ({
+                      ...rpc,
+                      [chain.id]: chain.rpcUrls.default.http[0]
+                    }),
+                    {}
+                  )
+                }
+              }
+            }),
+            ...this.options.qrcode ? [
+              new Promise(
+                (_res, reject) => provider.on(
+                  "display_uri",
+                  async (uri) => (await import("@walletconnect/qrcode-modal")).default.open(
+                    uri,
+                    () => reject(new Error("user rejected"))
+                  )
+                )
+              )
+            ] : []
+          ]);
+          if (this.options.qrcode)
+            (await import("@walletconnect/qrcode-modal")).default.close();
+        }
+      }
       setTimeout(() => this.emit("message", { type: "connecting" }), 0);
-      const accounts = await provider.enable();
+      const accounts = await Promise.race([
+        provider.enable(),
+        ...this.version === "1" && this.options.qrcode ? [
+          new Promise(
+            (_res, reject) => provider.connector.on(
+              "disconnect",
+              () => reject(new Error("user rejected"))
+            )
+          )
+        ] : []
+      ]);
       const account = getAddress(accounts[0]);
       const id = await this.getChainId();
       const unsupported = this.isChainUnsupported(id);
-      const walletName = provider.connector?.peerMeta?.name ?? "";
-      if (switchChainAllowedRegex.test(walletName))
+      if (this.version === "1") {
+        const walletName = provider.connector?.peerMeta?.name ?? "";
+        const switchChainAllowedRegex = /(imtoken|metamask|omni|rainbow|trust wallet)/i;
+        if (switchChainAllowedRegex.test(walletName))
+          this.switchChain = __privateMethod(this, _switchChain, switchChain_fn);
+      } else
         this.switchChain = __privateMethod(this, _switchChain, switchChain_fn);
       return {
         account,
@@ -72,47 +147,82 @@ var WalletConnectConnector = class extends Connector {
         )
       };
     } catch (error) {
-      if (/user closed modal/i.test(error.message))
+      if (this.version === "2" && this.options.qrcode)
+        (await import("@walletconnect/qrcode-modal")).default.close();
+      if (/user closed modal|user rejected/i.test(
+        error?.message
+      )) {
         throw new UserRejectedRequestError(error);
+      }
       throw error;
     }
   }
   async disconnect() {
     const provider = await this.getProvider();
-    await provider.disconnect();
+    try {
+      await provider.disconnect();
+    } catch (error) {
+      if (!/No matching key/i.test(error.message))
+        throw error;
+    }
     provider.removeListener("accountsChanged", this.onAccountsChanged);
     provider.removeListener("chainChanged", this.onChainChanged);
     provider.removeListener("disconnect", this.onDisconnect);
-    typeof localStorage !== "undefined" && localStorage.removeItem("walletconnect");
+    if (this.version === "1" && typeof localStorage !== "undefined")
+      localStorage.removeItem("walletconnect");
+    else {
+      provider.removeListener("session_delete", this.onDisconnect);
+      provider.removeListener("display_uri", this.onDisplayUri);
+    }
   }
   async getAccount() {
     const provider = await this.getProvider();
-    const accounts = provider.accounts;
+    let accounts;
+    if (this.version === "1")
+      accounts = provider.accounts;
+    else
+      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;
+    if (this.version === "1")
+      return normalizeChainId(provider.chainId);
+    return getClient().data?.chain?.id ?? normalizeChainId(await provider.request({ method: "eth_chainId" }));
   }
   async getProvider({
     chainId,
     create
   } = {}) {
     if (!__privateGet(this, _provider) || chainId || create) {
-      const rpc = !this.options?.infuraId ? this.chains.reduce(
-        (rpc2, chain) => ({
-          ...rpc2,
-          [chain.id]: chain.rpcUrls.default.http[0]
-        }),
-        {}
-      ) : {};
-      const WalletConnectProvider = (await import("@walletconnect/ethereum-provider")).default;
-      __privateSet(this, _provider, new WalletConnectProvider({
-        ...this.options,
-        chainId,
-        rpc: { ...rpc, ...this.options?.rpc }
-      }));
+      if (this.options.version === "2") {
+        const WalletConnectProvider = (await import("@walletconnect/universal-provider")).default;
+        __privateSet(this, _provider, await WalletConnectProvider.init(
+          this.options
+        ));
+        if (chainId)
+          __privateGet(this, _provider).setDefaultChain(
+            `${defaultV2Config.namespace}:${chainId}`
+          );
+        return __privateGet(this, _provider);
+      } else {
+        const rpc = !this.options?.infuraId ? this.chains.reduce(
+          (rpc2, chain) => ({
+            ...rpc2,
+            [chain.id]: chain.rpcUrls.default.http[0]
+          }),
+          {}
+        ) : {};
+        const WalletConnectProvider = (await import("@walletconnect/ethereum-provider")).default;
+        __privateSet(this, _provider, new WalletConnectProvider({
+          ...this.options,
+          chainId,
+          rpc: { ...rpc, ...this.options?.rpc }
+        }));
+        return __privateGet(this, _provider);
+      }
     }
     return __privateGet(this, _provider);
   }
@@ -121,21 +231,45 @@ var WalletConnectConnector = class extends Connector {
       this.getProvider({ chainId }),
       this.getAccount()
     ]);
-    return new providers.Web3Provider(
-      provider,
-      chainId
-    ).getSigner(account);
+    let provider_ = provider;
+    if (this.version === "2") {
+      const chainId_ = await this.getChainId();
+      provider_ = {
+        ...provider,
+        async request(args) {
+          return await provider.request(
+            args,
+            `${defaultV2Config.namespace}:${chainId ?? chainId_}`
+          );
+        }
+      };
+    }
+    return new providers.Web3Provider(provider_, chainId).getSigner(account);
   }
   async isAuthorized() {
     try {
-      const account = await this.getAccount();
-      return !!account;
+      const [account, isChainsAuthorized] = await Promise.all([
+        this.getAccount(),
+        __privateMethod(this, _isChainsAuthorized, isChainsAuthorized_fn).call(this)
+      ]);
+      return !!account && isChainsAuthorized;
     } catch {
       return false;
     }
   }
 };
 _provider = new WeakMap();
+_isChainsAuthorized = new WeakSet();
+isChainsAuthorized_fn = async function() {
+  const provider = await this.getProvider();
+  if (this.version === "1")
+    return true;
+  const providerChains = provider.namespaces?.[defaultV2Config.namespace]?.chains || [];
+  const authorizedChainIds = providerChains.map(
+    (chain) => parseInt(chain.split(":")[1] || "")
+  );
+  return !this.chains.some(({ id }) => !authorizedChainIds.includes(id));
+};
 _switchChain = new WeakSet();
 switchChain_fn = async function(chainId) {
   const provider = await this.getProvider();
@@ -153,11 +287,18 @@ switchChain_fn = async function(chainId) {
         })
       )
     ]);
+    if (this.version === "2") {
+      ;
+      provider.setDefaultChain(
+        `${defaultV2Config.namespace}:${chainId}`
+      );
+      this.onChainChanged(chainId);
+    }
     return this.chains.find((x) => x.id === chainId) ?? {
       id: chainId,
       name: `Chain ${id}`,
       network: `${id}`,
-      nativeCurrency: { name: "Ether", decimals: 18, symbol: "ETH" },
+      nativeCurrency: { decimals: 18, name: "Ether", symbol: "ETH" },
       rpcUrls: { default: { http: [""] } }
     };
   } catch (error) {

package/package.json

@@ -2,7 +2,7 @@
   "name": "@wagmi/connectors",
   "description": "A collection of connectors for wagmi",
   "license": "MIT",
-  "version": "0.1.2",
+  "version": "0.1.3",
   "peerDependencies": {
     "@wagmi/core": "0.8.x",
     "ethers": "^5.0.0"
@@ -16,6 +16,8 @@
     "@coinbase/wallet-sdk": "^3.5.4",
     "@ledgerhq/connect-kit-loader": "^1.0.1",
     "@walletconnect/ethereum-provider": "^1.8.0",
+    "@walletconnect/qrcode-modal": "^1.8.0",
+    "@walletconnect/universal-provider": "^2.1.4",
     "abitype": "^0.1.8",
     "eventemitter3": "^4.0.7"
   },