@wagmi/connectors 2.3.0 → 2.4.0

package/dist/{base-0473abd3.d.ts → base-2dd7facf.d.ts}

@@ -19,6 +19,7 @@ type InjectedProviderFlags = {
     isFrame?: true;
     isFrontier?: true;
     isGamestop?: true;
+    isHaqqWallet?: true;
     isHyperPay?: true;
     isImToken?: true;
     isKuCoinWallet?: true;

package/dist/{chunk-4BSCIAHY.js → chunk-Z2P63ELM.js}

@@ -61,6 +61,8 @@ function getInjectedName(ethereum) {
       return "Frontier Wallet";
     if (provider.isGamestop)
       return "GameStop Wallet";
+    if (provider.isHaqqWallet)
+      return "HAQQ Wallet";
     if (provider.isHyperPay)
       return "HyperPay Wallet";
     if (provider.isImToken)

package/dist/coinbaseWallet.d.ts

@@ -2,7 +2,7 @@ import * as viem from 'viem';
 import { CoinbaseWalletProvider } from '@coinbase/wallet-sdk';
 import { CoinbaseWalletSDKOptions } from '@coinbase/wallet-sdk/dist/CoinbaseWalletSDK';
 import { Chain } from '@wagmi/chains';
-import { C as Connector } from './base-0473abd3.js';
+import { C as Connector } from './base-2dd7facf.js';
 import 'eventemitter3';
 
 type Options = Omit<CoinbaseWalletSDKOptions, 'reloadOnDisconnect'> & {

package/dist/index.d.ts

@@ -1,4 +1,4 @@
-export { C as Connector, a as ConnectorData, b as ConnectorEvents, W as WindowProvider } from './base-0473abd3.js';
+export { C as Connector, a as ConnectorData, b as ConnectorEvents, W as WindowProvider } from './base-2dd7facf.js';
 import '@wagmi/chains';
 import 'eventemitter3';
 import 'viem';
@@ -15,4 +15,6 @@ declare class ConnectorNotFoundError extends Error {
     message: string;
 }
 
-export { ChainNotConfiguredForConnectorError, ConnectorNotFoundError };
+declare function normalizeChainId(chainId: string | number | bigint): number;
+
+export { ChainNotConfiguredForConnectorError, ConnectorNotFoundError, normalizeChainId };

package/dist/index.js

@@ -2,11 +2,15 @@ import {
   ChainNotConfiguredForConnectorError,
   ConnectorNotFoundError
 } from "./chunk-ZCAPXGBX.js";
+import {
+  normalizeChainId
+} from "./chunk-OQILYQDO.js";
 import {
   Connector
 } from "./chunk-QYMCVNHT.js";
 export {
   ChainNotConfiguredForConnectorError,
   Connector,
-  ConnectorNotFoundError
+  ConnectorNotFoundError,
+  normalizeChainId
 };

package/dist/injected.d.ts

@@ -1,7 +1,7 @@
 import * as viem from 'viem';
 import { Address } from 'viem';
 import { Chain } from '@wagmi/chains';
-import { W as WindowProvider, C as Connector } from './base-0473abd3.js';
+import { W as WindowProvider, C as Connector } from './base-2dd7facf.js';
 import 'eventemitter3';
 
 type InjectedConnectorOptions = {

package/dist/injected.js

@@ -1,6 +1,6 @@
 import {
   InjectedConnector
-} from "./chunk-4BSCIAHY.js";
+} from "./chunk-Z2P63ELM.js";
 import "./chunk-ZCAPXGBX.js";
 import "./chunk-OQILYQDO.js";
 import "./chunk-QYMCVNHT.js";

package/dist/ledger.d.ts

@@ -1,27 +1,52 @@
 import * as viem from 'viem';
 import { EthereumProvider } from '@ledgerhq/connect-kit-loader';
 import { Chain } from '@wagmi/chains';
-import { C as Connector, a as ConnectorData } from './base-0473abd3.js';
+import { EthereumProviderOptions } from '@walletconnect/ethereum-provider/dist/types/EthereumProvider';
+import { C as Connector } from './base-2dd7facf.js';
 import 'eventemitter3';
 
-type LedgerConnectorOptions = {
+type LedgerConnectorWcV1Options = {
+    walletConnectVersion?: 1;
     bridge?: string;
     chainId?: number;
-    enableDebugLogs?: boolean;
     rpc?: {
         [chainId: number]: string;
     };
 };
+type LedgerConnectorWcV2Options = {
+    walletConnectVersion?: 2;
+    projectId?: EthereumProviderOptions['projectId'];
+    requiredChains?: number[];
+    requiredMethods?: string[];
+    optionalMethods?: string[];
+    requiredEvents?: string[];
+    optionalEvents?: string[];
+};
+type LedgerConnectorOptions = {
+    enableDebugLogs?: boolean;
+} & (LedgerConnectorWcV1Options | LedgerConnectorWcV2Options);
+type ConnectConfig = {
+    /** Target chain to connect to. */
+    chainId?: number;
+};
 declare class LedgerConnector extends Connector<EthereumProvider, LedgerConnectorOptions> {
     #private;
     readonly id = "ledger";
     readonly name = "Ledger";
     readonly ready = true;
-    constructor({ chains, options, }?: {
+    get walletConnectVersion(): 1 | 2;
+    constructor(config: {
         chains?: Chain[];
-        options?: LedgerConnectorOptions;
+        options: LedgerConnectorOptions;
     });
-    connect(): Promise<Required<ConnectorData>>;
+    connect({ chainId }?: ConnectConfig): Promise<{
+        account: `0x${string}`;
+        chain: {
+            id: number;
+            unsupported: boolean;
+        };
+        provider: EthereumProvider;
+    }>;
     disconnect(): Promise<void>;
     getAccount(): Promise<`0x${string}`>;
     getChainId(): Promise<number>;
@@ -284,9 +309,11 @@ declare class LedgerConnector extends Connector<EthereumProvider, LedgerConnecto
         };
     }>;
     isAuthorized(): Promise<boolean>;
+    switchChain(chainId: number): Promise<Chain>;
     protected onAccountsChanged: (accounts: string[]) => void;
     protected onChainChanged: (chainId: number | string) => void;
     protected onDisconnect: () => void;
+    protected onConnect: () => void;
 }
 
 export { LedgerConnector };

package/dist/ledger.js

@@ -23,18 +23,23 @@ import {
   getAddress,
   numberToHex
 } from "viem";
-var _provider, _switchChain, switchChain_fn;
+var _provider, _initProviderPromise, _isV1, _createProvider, createProvider_fn, _initProvider, initProvider_fn, _setupListeners, setupListeners_fn, _removeListeners, removeListeners_fn;
 var LedgerConnector = class extends Connector {
-  constructor({
-    chains,
-    options = { enableDebugLogs: false }
-  } = {}) {
-    super({ chains, options });
-    __privateAdd(this, _switchChain);
+  constructor(config) {
+    super({
+      ...config,
+      options: { ...config.options }
+    });
+    __privateAdd(this, _createProvider);
+    __privateAdd(this, _initProvider);
+    __privateAdd(this, _setupListeners);
+    __privateAdd(this, _removeListeners);
     __publicField(this, "id", "ledger");
     __publicField(this, "name", "Ledger");
     __publicField(this, "ready", true);
     __privateAdd(this, _provider, void 0);
+    __privateAdd(this, _initProviderPromise, void 0);
+    __privateAdd(this, _isV1, void 0);
     __publicField(this, "onAccountsChanged", (accounts) => {
       if (accounts.length === 0)
         this.emit("disconnect");
@@ -49,48 +54,60 @@ var LedgerConnector = class extends Connector {
     __publicField(this, "onDisconnect", () => {
       this.emit("disconnect");
     });
+    __publicField(this, "onConnect", () => {
+      this.emit("connect", {});
+    });
+    __privateSet(this, _isV1, this.walletConnectVersion === 1);
   }
-  async connect() {
+  get walletConnectVersion() {
+    if (this.options.walletConnectVersion)
+      return this.options.walletConnectVersion;
+    else if (this.options.projectId)
+      return 2;
+    return 1;
+  }
+  async connect({ chainId } = {}) {
     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);
+      __privateMethod(this, _setupListeners, setupListeners_fn).call(this);
+      if (!provider.session) {
+        this.emit("message", { type: "connecting" });
+        await provider.request({
+          method: "eth_requestAccounts"
+        });
+      }
+      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);
       }
-      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 }
+        chain: { id, unsupported },
+        provider
       };
     } catch (error) {
-      if (error.code === 4001) {
+      if (/user rejected/i.test(error?.message)) {
         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);
+    try {
+      if (provider?.disconnect)
+        await provider.disconnect();
+    } catch (error) {
+      if (!/No matching key/i.test(error.message))
+        throw error;
+    } finally {
+      __privateMethod(this, _removeListeners, removeListeners_fn).call(this);
+      __privateGet(this, _isV1) && typeof localStorage !== "undefined" && localStorage.removeItem("walletconnect");
     }
-    typeof localStorage !== "undefined" && localStorage.removeItem("walletconnect");
   }
   async getAccount() {
     const provider = await this.getProvider();
@@ -110,26 +127,11 @@ var LedgerConnector = class extends Connector {
   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());
+    if (!__privateGet(this, _provider) || __privateGet(this, _isV1) && create) {
+      await __privateMethod(this, _createProvider, createProvider_fn).call(this);
     }
+    if (chainId)
+      await this.switchChain(chainId);
     return __privateGet(this, _provider);
   }
   async getWalletClient({ chainId } = {}) {
@@ -140,11 +142,7 @@ var LedgerConnector = class extends Connector {
     const chain = this.chains.find((x) => x.id === chainId);
     if (!provider)
       throw new Error("provider is required.");
-    return createWalletClient({
-      account,
-      chain,
-      transport: custom(provider)
-    });
+    return createWalletClient({ account, chain, transport: custom(provider) });
   }
   async isAuthorized() {
     try {
@@ -154,38 +152,108 @@ var LedgerConnector = class extends Connector {
       return false;
     }
   }
+  async switchChain(chainId) {
+    const chain = this.chains.find((chain2) => chain2.id === chainId);
+    if (!chain)
+      throw new SwitchChainError(new Error("chain not found on connector."));
+    try {
+      const provider = await this.getProvider();
+      await provider.request({
+        method: "wallet_switchEthereumChain",
+        params: [{ chainId: numberToHex(chainId) }]
+      });
+      return chain;
+    } 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);
+    }
+  }
 };
 _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);
-        })
+_initProviderPromise = new WeakMap();
+_isV1 = new WeakMap();
+_createProvider = new WeakSet();
+createProvider_fn = async function() {
+  if (!__privateGet(this, _initProviderPromise) && typeof window !== "undefined") {
+    __privateSet(this, _initProviderPromise, __privateMethod(this, _initProvider, initProvider_fn).call(this));
+  }
+  return __privateGet(this, _initProviderPromise);
+};
+_initProvider = new WeakSet();
+initProvider_fn = async function() {
+  const connectKit = await loadConnectKit();
+  if (this.options.enableDebugLogs) {
+    connectKit.enableDebugLogs();
+  }
+  let checkSupportOptions;
+  if (__privateGet(this, _isV1)) {
+    const { chainId, bridge } = this.options;
+    checkSupportOptions = {
+      providerType: SupportedProviders.Ethereum,
+      walletConnectVersion: 1,
+      chainId,
+      bridge,
+      rpc: Object.fromEntries(
+        this.chains.map((chain) => [
+          chain.id,
+          chain.rpcUrls.default.http[0]
+        ])
+      )
+    };
+  } else {
+    const {
+      projectId,
+      requiredChains,
+      requiredMethods,
+      optionalMethods,
+      requiredEvents,
+      optionalEvents
+    } = this.options;
+    const optionalChains = this.chains.map(({ id }) => id);
+    checkSupportOptions = {
+      providerType: SupportedProviders.Ethereum,
+      walletConnectVersion: 2,
+      projectId,
+      chains: requiredChains,
+      optionalChains,
+      methods: requiredMethods,
+      optionalMethods,
+      events: requiredEvents,
+      optionalEvents,
+      rpcMap: Object.fromEntries(
+        this.chains.map((chain) => [
+          chain.id,
+          chain.rpcUrls.default.http[0]
+        ])
       )
-    ]);
-    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);
   }
+  connectKit.checkSupport(checkSupportOptions);
+  __privateSet(this, _provider, await connectKit.getProvider());
+};
+_setupListeners = new WeakSet();
+setupListeners_fn = function() {
+  if (!__privateGet(this, _provider))
+    return;
+  __privateMethod(this, _removeListeners, removeListeners_fn).call(this);
+  __privateGet(this, _provider).on("accountsChanged", this.onAccountsChanged);
+  __privateGet(this, _provider).on("chainChanged", this.onChainChanged);
+  __privateGet(this, _provider).on("disconnect", this.onDisconnect);
+  __privateGet(this, _provider).on("session_delete", this.onDisconnect);
+  __privateGet(this, _provider).on("connect", this.onConnect);
+};
+_removeListeners = new WeakSet();
+removeListeners_fn = function() {
+  if (!__privateGet(this, _provider))
+    return;
+  __privateGet(this, _provider).removeListener("accountsChanged", this.onAccountsChanged);
+  __privateGet(this, _provider).removeListener("chainChanged", this.onChainChanged);
+  __privateGet(this, _provider).removeListener("disconnect", this.onDisconnect);
+  __privateGet(this, _provider).removeListener("session_delete", this.onDisconnect);
+  __privateGet(this, _provider).removeListener("connect", this.onConnect);
 };
 export {
   LedgerConnector

package/dist/metaMask.d.ts

@@ -1,6 +1,6 @@
 import { Chain } from '@wagmi/chains';
 import { InjectedConnectorOptions, InjectedConnector } from './injected.js';
-import { W as WindowProvider } from './base-0473abd3.js';
+import { W as WindowProvider } from './base-2dd7facf.js';
 import 'viem';
 import 'eventemitter3';
 

package/dist/metaMask.js

@@ -1,6 +1,6 @@
 import {
   InjectedConnector
-} from "./chunk-4BSCIAHY.js";
+} from "./chunk-Z2P63ELM.js";
 import {
   ConnectorNotFoundError
 } from "./chunk-ZCAPXGBX.js";

package/dist/mock/index.d.ts

@@ -1,6 +1,6 @@
 import * as viem from 'viem';
 import { Chain } from '@wagmi/chains';
-import { c as WalletClient, C as Connector, a as ConnectorData } from '../base-0473abd3.js';
+import { c as WalletClient, C as Connector, a as ConnectorData } from '../base-2dd7facf.js';
 import EventEmitter from 'eventemitter3';
 
 type MockProviderOptions = {

package/dist/safe.d.ts

@@ -2,7 +2,7 @@ import * as viem from 'viem';
 import { SafeAppProvider } from '@safe-global/safe-apps-provider';
 import { Opts } from '@safe-global/safe-apps-sdk';
 import { Chain } from '@wagmi/chains';
-import { C as Connector } from './base-0473abd3.js';
+import { C as Connector } from './base-2dd7facf.js';
 import 'eventemitter3';
 
 type SafeConnectorProvider = SafeAppProvider;

package/dist/walletConnect.d.ts

@@ -2,7 +2,7 @@ import * as viem from 'viem';
 import { Chain } from '@wagmi/chains';
 import WalletConnectProvider from '@walletconnect/ethereum-provider';
 import { EthereumProviderOptions } from '@walletconnect/ethereum-provider/dist/types/EthereumProvider';
-import { C as Connector } from './base-0473abd3.js';
+import { C as Connector } from './base-2dd7facf.js';
 import 'eventemitter3';
 
 type WalletConnectOptions = {

package/dist/walletConnectLegacy.d.ts

@@ -1,7 +1,7 @@
 import * as viem from 'viem';
 import { Chain } from '@wagmi/chains';
 import WalletConnectProvider from '@walletconnect/legacy-provider';
-import { C as Connector } from './base-0473abd3.js';
+import { C as Connector } from './base-2dd7facf.js';
 import 'eventemitter3';
 
 type WalletConnectOptions = ConstructorParameters<typeof WalletConnectProvider>[0];

package/package.json

@@ -2,9 +2,9 @@
   "name": "@wagmi/connectors",
   "description": "A collection of connectors for wagmi",
   "license": "MIT",
-  "version": "2.3.0",
+  "version": "2.4.0",
   "peerDependencies": {
-    "@wagmi/chains": ">=1.2.0",
+    "@wagmi/chains": ">=1.3.0",
     "typescript": ">=5.0.4",
     "viem": ">=0.3.35"
   },
@@ -18,18 +18,18 @@
   },
   "dependencies": {
     "@coinbase/wallet-sdk": "^3.6.6",
-    "@ledgerhq/connect-kit-loader": "^1.0.1",
+    "@ledgerhq/connect-kit-loader": "^1.1.0",
+    "@safe-global/safe-apps-provider": "^0.15.2",
+    "@safe-global/safe-apps-sdk": "^7.9.0",
     "@walletconnect/ethereum-provider": "2.8.1",
     "@walletconnect/legacy-provider": "^2.0.0",
     "@walletconnect/modal": "^2.4.6",
-    "@safe-global/safe-apps-provider": "^0.15.2",
-    "@safe-global/safe-apps-sdk": "^7.9.0",
     "abitype": "0.8.7",
     "eventemitter3": "^4.0.7"
   },
   "devDependencies": {
     "viem": "^1.0.0",
-    "@wagmi/chains": "1.2.0"
+    "@wagmi/chains": "1.3.0"
   },
   "type": "module",
   "main": "dist/index.js",