@wagmi/connectors 0.3.19 → 1.0.0-cjs

package/README.md

@@ -12,16 +12,16 @@ npm i @wagmi/connectors
 
 ## Usage
 
-Configure your wagmi client with connectors!
+Configure your wagmi config with connectors!
 
 ```tsx
-import { configureChains, createClient } from 'wagmi'
+import { configureChains, createConfig } from 'wagmi'
 
 import { InjectedConnector } from '@wagmi/connectors/injected'
 
 const { chains, provider } = configureChains(...)
 
-const client = createClient({
+const config = createConfig({
   connectors: [
     new InjectedConnector({ chains }),
   ],

package/coinbaseWallet/package.json

@@ -1,4 +1,4 @@
 {
-  "type": "module",
+  "module": "../dist/coinbaseWallet.mjs",
   "main": "../dist/coinbaseWallet.js"
 }

package/dist/base-b7cfab8e.d.ts

@@ -0,0 +1,133 @@
+import { Chain as Chain$1 } from '@wagmi/chains';
+import { Address } from 'abitype';
+import EventEmitter from 'eventemitter3';
+import { EIP1193Provider, Transport, Chain, Account, WalletClient as WalletClient$1 } from 'viem';
+
+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;
+    isHaloWallet?: 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 WindowProvider extends InjectedProviders, EIP1193Provider {
+    providers?: WindowProvider[];
+}
+type WalletClient<TTransport extends Transport = Transport, TChain extends Chain = Chain, TAccount extends Account = Account> = WalletClient$1<TTransport, TChain, TAccount>;
+type Storage = {
+    getItem<T>(key: string, defaultState?: T | null): T | null;
+    setItem<T>(key: string, value: T | null): void;
+    removeItem(key: string): void;
+};
+
+type ConnectorData = {
+    account?: Address;
+    chain?: {
+        id: number;
+        unsupported: boolean;
+    };
+};
+interface ConnectorEvents {
+    change(data: ConnectorData): void;
+    connect(data: ConnectorData): void;
+    message({ type, data }: {
+        type: string;
+        data?: unknown;
+    }): void;
+    disconnect(): void;
+    error(error: Error): void;
+}
+declare abstract class Connector<Provider = any, Options = any> extends EventEmitter<ConnectorEvents> {
+    /** Unique connector id */
+    abstract readonly id: string;
+    /** Connector name */
+    abstract readonly name: string;
+    /** Chains connector supports */
+    readonly chains: Chain$1[];
+    /** Options to use with connector */
+    readonly options: Options;
+    /** Connector storage. */
+    protected storage?: Storage;
+    /** Whether connector is usable */
+    abstract readonly ready: boolean;
+    constructor({ chains, options, }: {
+        chains?: Chain$1[];
+        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 getWalletClient(config?: {
+        chainId?: number;
+    }): Promise<WalletClient>;
+    abstract isAuthorized(): Promise<boolean>;
+    switchChain?(chainId: number): Promise<Chain$1>;
+    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$1): string[] | undefined;
+    protected isChainUnsupported(chainId: number): boolean;
+    setStorage(storage: Storage): void;
+}
+
+export { Connector as C, WindowProvider as W, ConnectorData as a, ConnectorEvents as b, WalletClient as c };

package/dist/{chunk-2VZS2JHJ.js → chunk-HIOOQYJ7.js}

@@ -1,25 +1,28 @@
-import {
-  Connector,
-  __privateAdd,
-  __privateGet,
-  __privateSet,
-  __publicField
-} from "./chunk-5NCTPR6C.js";
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }
+
+
+var _chunkZCAPXGBXjs = require('./chunk-ZCAPXGBX.js');
+
+
+var _chunkOQILYQDOjs = require('./chunk-OQILYQDO.js');
+
+
+
+
+
+
+var _chunkQYMCVNHTjs = require('./chunk-QYMCVNHT.js');
 
 // src/injected.ts
-import {
-  AddChainError,
-  ChainNotConfiguredError,
-  ConnectorNotFoundError,
-  ProviderRpcError,
-  ResourceUnavailableError,
-  SwitchChainError,
-  UserRejectedRequestError,
-  getClient,
-  normalizeChainId
-} from "@wagmi/core";
-import { providers } from "ethers";
-import { getAddress, hexValue } from "ethers/lib/utils.js";
+
+
+
+
+
+
+
+
+var _viem = require('viem');
 
 // src/utils/getInjectedName.ts
 function getInjectedName(ethereum) {
@@ -60,6 +63,8 @@ function getInjectedName(ethereum) {
       return "HyperPay Wallet";
     if (provider.isImToken)
       return "ImToken";
+    if (provider.isHaloWallet)
+      return "Halo Wallet";
     if (provider.isKuCoinWallet)
       return "KuCoin Wallet";
     if (provider.isMathWallet)
@@ -95,7 +100,7 @@ function getInjectedName(ethereum) {
     if (provider.isMetaMask)
       return "MetaMask";
   };
-  if (ethereum.providers?.length) {
+  if (_optionalChain([ethereum, 'access', _ => _.providers, 'optionalAccess', _2 => _2.length])) {
     const nameSet = /* @__PURE__ */ new Set();
     let unknownCount = 1;
     for (const provider of ethereum.providers) {
@@ -109,43 +114,50 @@ function getInjectedName(ethereum) {
     const names = [...nameSet];
     if (names.length)
       return names;
-    return names[0] ?? "Injected";
+    return _nullishCoalesce(names[0], () => ( "Injected"));
   }
-  return getName(ethereum) ?? "Injected";
+  return _nullishCoalesce(getName(ethereum), () => ( "Injected"));
 }
 
 // src/injected.ts
 var _provider;
-var InjectedConnector = class extends Connector {
+var InjectedConnector = class extends _chunkQYMCVNHTjs.Connector {
   constructor({
     chains,
     options: options_
   } = {}) {
     const options = {
       shimDisconnect: true,
-      getProvider: () => typeof window !== "undefined" ? window.ethereum : void 0,
+      getProvider() {
+        if (typeof window === "undefined")
+          return;
+        const ethereum = window.ethereum;
+        if (_optionalChain([ethereum, 'optionalAccess', _3 => _3.providers]))
+          return ethereum.providers[0];
+        return ethereum;
+      },
       ...options_
     };
     super({ chains, options });
-    __publicField(this, "id", "injected");
-    __publicField(this, "name");
-    __publicField(this, "ready");
-    __privateAdd(this, _provider, void 0);
-    __publicField(this, "shimDisconnectKey", `${this.id}.shimDisconnect`);
-    __publicField(this, "onAccountsChanged", (accounts) => {
+    _chunkQYMCVNHTjs.__publicField.call(void 0, this, "id", "injected");
+    _chunkQYMCVNHTjs.__publicField.call(void 0, this, "name");
+    _chunkQYMCVNHTjs.__publicField.call(void 0, this, "ready");
+    _chunkQYMCVNHTjs.__privateAdd.call(void 0, this, _provider, void 0);
+    _chunkQYMCVNHTjs.__publicField.call(void 0, this, "shimDisconnectKey", `${this.id}.shimDisconnect`);
+    _chunkQYMCVNHTjs.__publicField.call(void 0, this, "onAccountsChanged", (accounts) => {
       if (accounts.length === 0)
         this.emit("disconnect");
       else
         this.emit("change", {
-          account: getAddress(accounts[0])
+          account: _viem.getAddress.call(void 0, accounts[0])
         });
     });
-    __publicField(this, "onChainChanged", (chainId) => {
-      const id = normalizeChainId(chainId);
+    _chunkQYMCVNHTjs.__publicField.call(void 0, this, "onChainChanged", (chainId) => {
+      const id = _chunkOQILYQDOjs.normalizeChainId.call(void 0, chainId);
       const unsupported = this.isChainUnsupported(id);
       this.emit("change", { chain: { id, unsupported } });
     });
-    __publicField(this, "onDisconnect", async (error) => {
+    _chunkQYMCVNHTjs.__publicField.call(void 0, this, "onDisconnect", async (error) => {
       if (error.code === 1013) {
         const provider = await this.getProvider();
         if (provider) {
@@ -156,7 +168,7 @@ var InjectedConnector = class extends Connector {
       }
       this.emit("disconnect");
       if (this.options.shimDisconnect)
-        getClient().storage?.removeItem(this.shimDisconnectKey);
+        _optionalChain([this, 'access', _4 => _4.storage, 'optionalAccess', _5 => _5.removeItem, 'call', _6 => _6(this.shimDisconnectKey)]);
     });
     const provider = options.getProvider();
     if (typeof options.name === "string")
@@ -179,7 +191,7 @@ var InjectedConnector = class extends Connector {
     try {
       const provider = await this.getProvider();
       if (!provider)
-        throw new ConnectorNotFoundError();
+        throw new (0, _chunkZCAPXGBXjs.ConnectorNotFoundError)();
       if (provider.on) {
         provider.on("accountsChanged", this.onAccountsChanged);
         provider.on("chainChanged", this.onChainChanged);
@@ -189,7 +201,7 @@ var InjectedConnector = class extends Connector {
       const accounts = await provider.request({
         method: "eth_requestAccounts"
       });
-      const account = getAddress(accounts[0]);
+      const account = _viem.getAddress.call(void 0, accounts[0]);
       let id = await this.getChainId();
       let unsupported = this.isChainUnsupported(id);
       if (chainId && id !== chainId) {
@@ -198,75 +210,79 @@ var InjectedConnector = class extends Connector {
         unsupported = this.isChainUnsupported(id);
       }
       if (this.options.shimDisconnect)
-        getClient().storage?.setItem(this.shimDisconnectKey, true);
-      return { account, chain: { id, unsupported }, provider };
+        _optionalChain([this, 'access', _7 => _7.storage, 'optionalAccess', _8 => _8.setItem, 'call', _9 => _9(this.shimDisconnectKey, true)]);
+      return { account, chain: { id, unsupported } };
     } catch (error) {
       if (this.isUserRejectedRequestError(error))
-        throw new UserRejectedRequestError(error);
+        throw new (0, _viem.UserRejectedRequestError)(error);
       if (error.code === -32002)
-        throw new ResourceUnavailableError(error);
+        throw new (0, _viem.ResourceNotFoundRpcError)(error);
       throw error;
     }
   }
   async disconnect() {
     const provider = await this.getProvider();
-    if (!provider?.removeListener)
+    if (!_optionalChain([provider, 'optionalAccess', _10 => _10.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);
+      _optionalChain([this, 'access', _11 => _11.storage, 'optionalAccess', _12 => _12.removeItem, 'call', _13 => _13(this.shimDisconnectKey)]);
   }
   async getAccount() {
     const provider = await this.getProvider();
     if (!provider)
-      throw new ConnectorNotFoundError();
+      throw new (0, _chunkZCAPXGBXjs.ConnectorNotFoundError)();
     const accounts = await provider.request({
       method: "eth_accounts"
     });
-    return getAddress(accounts[0]);
+    return _viem.getAddress.call(void 0, accounts[0]);
   }
   async getChainId() {
     const provider = await this.getProvider();
     if (!provider)
-      throw new ConnectorNotFoundError();
-    return provider.request({ method: "eth_chainId" }).then(normalizeChainId);
+      throw new (0, _chunkZCAPXGBXjs.ConnectorNotFoundError)();
+    return provider.request({ method: "eth_chainId" }).then(_chunkOQILYQDOjs.normalizeChainId);
   }
   async getProvider() {
     const provider = this.options.getProvider();
     if (provider)
-      __privateSet(this, _provider, provider);
-    return __privateGet(this, _provider);
+      _chunkQYMCVNHTjs.__privateSet.call(void 0, this, _provider, provider);
+    return _chunkQYMCVNHTjs.__privateGet.call(void 0, this, _provider);
   }
-  async getSigner({ chainId } = {}) {
+  async getWalletClient({ chainId } = {}) {
     const [provider, account] = await Promise.all([
       this.getProvider(),
       this.getAccount()
     ]);
-    return new providers.Web3Provider(
-      provider,
-      chainId
-    ).getSigner(account);
+    const chain = this.chains.find((x) => x.id === chainId) || this.chains[0];
+    if (!provider)
+      throw new Error("provider is required.");
+    return _viem.createWalletClient.call(void 0, {
+      account,
+      chain,
+      transport: _viem.custom.call(void 0, provider)
+    });
   }
   async isAuthorized() {
     try {
-      if (this.options.shimDisconnect && !getClient().storage?.getItem(this.shimDisconnectKey))
+      if (this.options.shimDisconnect && !_optionalChain([this, 'access', _14 => _14.storage, 'optionalAccess', _15 => _15.getItem, 'call', _16 => _16(this.shimDisconnectKey)]))
         return false;
       const provider = await this.getProvider();
       if (!provider)
-        throw new ConnectorNotFoundError();
+        throw new (0, _chunkZCAPXGBXjs.ConnectorNotFoundError)();
       const account = await this.getAccount();
       return !!account;
-    } catch {
+    } catch (e) {
       return false;
     }
   }
   async switchChain(chainId) {
     const provider = await this.getProvider();
     if (!provider)
-      throw new ConnectorNotFoundError();
-    const id = hexValue(chainId);
+      throw new (0, _chunkZCAPXGBXjs.ConnectorNotFoundError)();
+    const id = _viem.numberToHex.call(void 0, chainId);
     try {
       await Promise.all([
         provider.request({
@@ -275,23 +291,26 @@ var InjectedConnector = class extends Connector {
         }),
         new Promise(
           (res) => this.on("change", ({ chain }) => {
-            if (chain?.id === chainId)
+            if (_optionalChain([chain, 'optionalAccess', _17 => _17.id]) === chainId)
               res();
           })
         )
       ]);
-      return this.chains.find((x) => x.id === chainId) ?? {
+      return _nullishCoalesce(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 || error?.data?.originalError?.code === 4902) {
+        throw new (0, _chunkZCAPXGBXjs.ChainNotConfiguredForConnectorError)({
+          chainId,
+          connectorId: this.id
+        });
+      if (error.code === 4902 || _optionalChain([error, 'optionalAccess', _18 => _18.data, 'optionalAccess', _19 => _19.originalError, 'optionalAccess', _20 => _20.code]) === 4902) {
         try {
           await provider.request({
             method: "wallet_addEthereumChain",
@@ -300,27 +319,24 @@ var InjectedConnector = class extends Connector {
                 chainId: id,
                 chainName: chain.name,
                 nativeCurrency: chain.nativeCurrency,
-                rpcUrls: [chain.rpcUrls.public?.http[0] ?? ""],
+                rpcUrls: [_nullishCoalesce(_optionalChain([chain, 'access', _21 => _21.rpcUrls, 'access', _22 => _22.public, 'optionalAccess', _23 => _23.http, 'access', _24 => _24[0]]), () => ( ""))],
                 blockExplorerUrls: this.getBlockExplorerUrls(chain)
               }
             ]
           });
           const currentChainId = await this.getChainId();
           if (currentChainId !== chainId)
-            throw new ProviderRpcError(
-              "User rejected switch after adding network.",
-              { code: 4001 }
+            throw new (0, _viem.UserRejectedRequestError)(
+              new Error("User rejected switch after adding network.")
             );
           return chain;
-        } catch (addError) {
-          if (this.isUserRejectedRequestError(addError))
-            throw new UserRejectedRequestError(addError);
-          throw new AddChainError();
+        } catch (error2) {
+          throw new (0, _viem.UserRejectedRequestError)(error2);
         }
       }
       if (this.isUserRejectedRequestError(error))
-        throw new UserRejectedRequestError(error);
-      throw new SwitchChainError(error);
+        throw new (0, _viem.UserRejectedRequestError)(error);
+      throw new (0, _viem.SwitchChainError)(error);
     }
   }
   async watchAsset({
@@ -331,7 +347,7 @@ var InjectedConnector = class extends Connector {
   }) {
     const provider = await this.getProvider();
     if (!provider)
-      throw new ConnectorNotFoundError();
+      throw new (0, _chunkZCAPXGBXjs.ConnectorNotFoundError)();
     return provider.request({
       method: "wallet_watchAsset",
       params: {
@@ -351,6 +367,6 @@ var InjectedConnector = class extends Connector {
 };
 _provider = new WeakMap();
 
-export {
-  InjectedConnector
-};
+
+
+exports.InjectedConnector = InjectedConnector;

package/dist/chunk-OQILYQDO.js

@@ -0,0 +1,15 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});// src/utils/normalizeChainId.ts
+function normalizeChainId(chainId) {
+  if (typeof chainId === "string")
+    return Number.parseInt(
+      chainId,
+      chainId.trim().substring(0, 2) === "0x" ? 16 : 10
+    );
+  if (typeof chainId === "bigint")
+    return Number(chainId);
+  return chainId;
+}
+
+
+
+exports.normalizeChainId = normalizeChainId;

package/dist/{chunk-5NCTPR6C.js → chunk-QYMCVNHT.js}

@@ -1,4 +1,4 @@
-var __defProp = Object.defineProperty;
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } }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);
@@ -28,21 +28,22 @@ var __privateMethod = (obj, member, method) => {
 };
 
 // src/base.ts
-import { goerli, mainnet } from "@wagmi/core/chains";
-import { default as EventEmitter } from "eventemitter3";
-var Connector = class extends EventEmitter {
+var _eventemitter3 = require('eventemitter3'); var _eventemitter32 = _interopRequireDefault(_eventemitter3);
+var _chains = require('viem/chains');
+var Connector = class extends _eventemitter32.default {
   constructor({
-    chains = [mainnet, goerli],
+    chains = [_chains.mainnet, _chains.goerli],
     options
   }) {
     super();
     __publicField(this, "chains");
     __publicField(this, "options");
+    __publicField(this, "storage");
     this.chains = chains;
     this.options = options;
   }
   getBlockExplorerUrls(chain) {
-    const { default: blockExplorer, ...blockExplorers } = chain.blockExplorers ?? {};
+    const { default: blockExplorer, ...blockExplorers } = _nullishCoalesce(chain.blockExplorers, () => ( {}));
     if (blockExplorer)
       return [
         blockExplorer.url,
@@ -52,13 +53,16 @@ var Connector = class extends EventEmitter {
   isChainUnsupported(chainId) {
     return !this.chains.some((x) => x.id === chainId);
   }
+  setStorage(storage) {
+    this.storage = storage;
+  }
 };
 
-export {
-  __publicField,
-  __privateGet,
-  __privateAdd,
-  __privateSet,
-  __privateMethod,
-  Connector
-};
+
+
+
+
+
+
+
+exports.__publicField = __publicField; exports.__privateGet = __privateGet; exports.__privateAdd = __privateAdd; exports.__privateSet = __privateSet; exports.__privateMethod = __privateMethod; exports.Connector = Connector;

package/dist/chunk-ZCAPXGBX.js

@@ -0,0 +1,26 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+var _chunkQYMCVNHTjs = require('./chunk-QYMCVNHT.js');
+
+// src/errors.ts
+var ChainNotConfiguredForConnectorError = class extends Error {
+  constructor({
+    chainId,
+    connectorId
+  }) {
+    super(`Chain "${chainId}" not configured for connector "${connectorId}".`);
+    _chunkQYMCVNHTjs.__publicField.call(void 0, this, "name", "ChainNotConfiguredForConnectorError");
+  }
+};
+var ConnectorNotFoundError = class extends Error {
+  constructor() {
+    super(...arguments);
+    _chunkQYMCVNHTjs.__publicField.call(void 0, this, "name", "ConnectorNotFoundError");
+    _chunkQYMCVNHTjs.__publicField.call(void 0, this, "message", "Connector not found");
+  }
+};
+
+
+
+
+exports.ChainNotConfiguredForConnectorError = ChainNotConfiguredForConnectorError; exports.ConnectorNotFoundError = ConnectorNotFoundError;