@wagmi/core 0.6.12 → 0.7.0

package/dist/chunk-4DNFSL2K.js

@@ -0,0 +1,376 @@
+// src/constants/blockExplorers.ts
+var etherscanBlockExplorers = {
+  mainnet: {
+    name: "Etherscan",
+    url: "https://etherscan.io"
+  },
+  goerli: {
+    name: "Etherscan",
+    url: "https://goerli.etherscan.io"
+  },
+  sepolia: {
+    name: "Etherscan",
+    url: "https://sepolia.etherscan.io"
+  },
+  optimism: {
+    name: "Etherscan",
+    url: "https://optimistic.etherscan.io"
+  },
+  optimismGoerli: {
+    name: "Etherscan",
+    url: "https://goerli-optimism.etherscan.io"
+  },
+  polygon: {
+    name: "PolygonScan",
+    url: "https://polygonscan.com"
+  },
+  polygonMumbai: {
+    name: "PolygonScan",
+    url: "https://mumbai.polygonscan.com"
+  },
+  arbitrum: { name: "Arbiscan", url: "https://arbiscan.io" },
+  arbitrumGoerli: { name: "Arbiscan", url: "https://goerli.arbiscan.io" }
+};
+
+// src/constants/rpcs.ts
+var alchemyRpcUrls = {
+  mainnet: "https://eth-mainnet.alchemyapi.io/v2",
+  goerli: "https://eth-goerli.alchemyapi.io/v2",
+  optimism: "https://opt-mainnet.g.alchemy.com/v2",
+  optimismGoerli: "https://opt-goerli.g.alchemy.com/v2",
+  polygon: "https://polygon-mainnet.g.alchemy.com/v2",
+  polygonMumbai: "https://polygon-mumbai.g.alchemy.com/v2",
+  arbitrum: "https://arb-mainnet.g.alchemy.com/v2",
+  arbitrumGoerli: "https://arb-goerli.g.alchemy.com/v2"
+};
+var infuraRpcUrls = {
+  mainnet: "https://mainnet.infura.io/v3",
+  goerli: "https://goerli.infura.io/v3",
+  sepolia: "https://sepolia.infura.io/v3",
+  optimism: "https://optimism-mainnet.infura.io/v3",
+  optimismGoerli: "https://optimism-goerli.infura.io/v3",
+  polygon: "https://polygon-mainnet.infura.io/v3",
+  polygonMumbai: "https://polygon-mumbai.infura.io/v3",
+  arbitrum: "https://arbitrum-mainnet.infura.io/v3",
+  arbitrumGoerli: "https://arbitrum-goerli.infura.io/v3"
+};
+var publicRpcUrls = {
+  mainnet: "https://cloudflare-eth.com",
+  goerli: "https://rpc.ankr.com/eth_goerli",
+  sepolia: "https://rpc.sepolia.org",
+  optimism: "https://mainnet.optimism.io",
+  optimismGoerli: "https://goerli.optimism.io",
+  polygon: "https://polygon-rpc.com",
+  polygonMumbai: "https://matic-mumbai.chainstacklabs.com",
+  arbitrum: "https://arb1.arbitrum.io/rpc",
+  arbitrumGoerli: "https://goerli-rollup.arbitrum.io/rpc"
+};
+
+// src/constants/chains.ts
+var chainId = {
+  mainnet: 1,
+  goerli: 5,
+  sepolia: 11155111,
+  optimism: 10,
+  optimismGoerli: 420,
+  polygon: 137,
+  polygonMumbai: 80001,
+  arbitrum: 42161,
+  arbitrumGoerli: 421613,
+  localhost: 1337,
+  hardhat: 31337,
+  foundry: 31337
+};
+var mainnet = {
+  id: chainId.mainnet,
+  name: "Ethereum",
+  network: "homestead",
+  nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
+  rpcUrls: {
+    alchemy: alchemyRpcUrls.mainnet,
+    default: publicRpcUrls.mainnet,
+    infura: infuraRpcUrls.mainnet,
+    public: publicRpcUrls.mainnet
+  },
+  blockExplorers: {
+    etherscan: etherscanBlockExplorers.mainnet,
+    default: etherscanBlockExplorers.mainnet
+  },
+  ens: {
+    address: "0x00000000000C2E074eC69A0dFb2997BA6C7d2e1e"
+  },
+  multicall: {
+    address: "0xca11bde05977b3631167028862be2a173976ca11",
+    blockCreated: 14353601
+  }
+};
+var goerli = {
+  id: chainId.goerli,
+  name: "Goerli",
+  network: "goerli",
+  nativeCurrency: { name: "Goerli Ether", symbol: "ETH", decimals: 18 },
+  rpcUrls: {
+    alchemy: alchemyRpcUrls.goerli,
+    default: publicRpcUrls.goerli,
+    infura: infuraRpcUrls.goerli,
+    public: publicRpcUrls.goerli
+  },
+  blockExplorers: {
+    etherscan: etherscanBlockExplorers.goerli,
+    default: etherscanBlockExplorers.goerli
+  },
+  ens: {
+    address: "0x00000000000C2E074eC69A0dFb2997BA6C7d2e1e"
+  },
+  multicall: {
+    address: "0xca11bde05977b3631167028862be2a173976ca11",
+    blockCreated: 6507670
+  },
+  testnet: true
+};
+var sepolia = {
+  id: chainId.sepolia,
+  name: "Sepolia",
+  network: "sepolia",
+  nativeCurrency: { name: "Sepolia Ether", symbol: "ETH", decimals: 18 },
+  rpcUrls: {
+    default: publicRpcUrls.sepolia,
+    infura: infuraRpcUrls.sepolia,
+    public: publicRpcUrls.sepolia
+  },
+  blockExplorers: {
+    etherscan: etherscanBlockExplorers.sepolia,
+    default: etherscanBlockExplorers.sepolia
+  },
+  multicall: {
+    address: "0xca11bde05977b3631167028862be2a173976ca11",
+    blockCreated: 751532
+  },
+  testnet: true
+};
+var optimism = {
+  id: chainId.optimism,
+  name: "Optimism",
+  network: "optimism",
+  nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
+  rpcUrls: {
+    alchemy: alchemyRpcUrls.optimism,
+    default: publicRpcUrls.optimism,
+    infura: infuraRpcUrls.optimism,
+    public: publicRpcUrls.optimism
+  },
+  blockExplorers: {
+    etherscan: etherscanBlockExplorers.optimism,
+    default: etherscanBlockExplorers.optimism
+  },
+  multicall: {
+    address: "0xca11bde05977b3631167028862be2a173976ca11",
+    blockCreated: 4286263
+  }
+};
+var optimismGoerli = {
+  id: chainId.optimismGoerli,
+  name: "Optimism Goerli",
+  network: "optimism-goerli",
+  nativeCurrency: {
+    name: "Goerli Ether",
+    symbol: "ETH",
+    decimals: 18
+  },
+  rpcUrls: {
+    alchemy: alchemyRpcUrls.optimismGoerli,
+    default: publicRpcUrls.optimismGoerli,
+    infura: infuraRpcUrls.optimismGoerli,
+    public: publicRpcUrls.optimismGoerli
+  },
+  blockExplorers: {
+    etherscan: etherscanBlockExplorers.optimismGoerli,
+    default: etherscanBlockExplorers.optimismGoerli
+  },
+  multicall: {
+    address: "0xca11bde05977b3631167028862be2a173976ca11",
+    blockCreated: 49461
+  },
+  testnet: true
+};
+var polygon = {
+  id: chainId.polygon,
+  name: "Polygon",
+  network: "matic",
+  nativeCurrency: { name: "MATIC", symbol: "MATIC", decimals: 18 },
+  rpcUrls: {
+    alchemy: alchemyRpcUrls.polygon,
+    default: publicRpcUrls.polygon,
+    infura: infuraRpcUrls.polygon,
+    public: publicRpcUrls.polygon
+  },
+  blockExplorers: {
+    etherscan: etherscanBlockExplorers.polygon,
+    default: etherscanBlockExplorers.polygon
+  },
+  multicall: {
+    address: "0xca11bde05977b3631167028862be2a173976ca11",
+    blockCreated: 25770160
+  }
+};
+var polygonMumbai = {
+  id: chainId.polygonMumbai,
+  name: "Polygon Mumbai",
+  network: "maticmum",
+  nativeCurrency: {
+    name: "MATIC",
+    symbol: "MATIC",
+    decimals: 18
+  },
+  rpcUrls: {
+    alchemy: alchemyRpcUrls.polygonMumbai,
+    default: publicRpcUrls.polygonMumbai,
+    infura: infuraRpcUrls.polygonMumbai,
+    public: publicRpcUrls.polygonMumbai
+  },
+  blockExplorers: {
+    etherscan: etherscanBlockExplorers.polygonMumbai,
+    default: etherscanBlockExplorers.polygonMumbai
+  },
+  multicall: {
+    address: "0xca11bde05977b3631167028862be2a173976ca11",
+    blockCreated: 25444704
+  },
+  testnet: true
+};
+var arbitrum = {
+  id: chainId.arbitrum,
+  name: "Arbitrum One",
+  network: "arbitrum",
+  nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
+  rpcUrls: {
+    alchemy: alchemyRpcUrls.arbitrum,
+    default: publicRpcUrls.arbitrum,
+    infura: infuraRpcUrls.arbitrum,
+    public: publicRpcUrls.arbitrum
+  },
+  blockExplorers: {
+    arbitrum: {
+      name: "Arbitrum Explorer",
+      url: "https://explorer.arbitrum.io"
+    },
+    etherscan: etherscanBlockExplorers.arbitrum,
+    default: etherscanBlockExplorers.arbitrum
+  },
+  multicall: {
+    address: "0xca11bde05977b3631167028862be2a173976ca11",
+    blockCreated: 7654707
+  }
+};
+var arbitrumGoerli = {
+  id: chainId.arbitrumGoerli,
+  name: "Arbitrum Goerli",
+  network: "arbitrum-goerli",
+  nativeCurrency: {
+    name: "Arbitrum Goerli Ether",
+    symbol: "ETH",
+    decimals: 18
+  },
+  rpcUrls: {
+    alchemy: alchemyRpcUrls.arbitrumGoerli,
+    default: publicRpcUrls.arbitrumGoerli,
+    infura: infuraRpcUrls.arbitrumGoerli,
+    public: publicRpcUrls.arbitrumGoerli
+  },
+  blockExplorers: {
+    arbitrum: {
+      name: "Arbitrum Explorer",
+      url: "https://goerli-rollup-explorer.arbitrum.io"
+    },
+    etherscan: etherscanBlockExplorers.arbitrumGoerli,
+    default: etherscanBlockExplorers.arbitrumGoerli
+  },
+  multicall: {
+    address: "0xca11bde05977b3631167028862be2a173976ca11",
+    blockCreated: 88114
+  },
+  testnet: true
+};
+var localhost = {
+  id: chainId.localhost,
+  name: "Localhost",
+  network: "localhost",
+  rpcUrls: {
+    default: "http://127.0.0.1:8545"
+  }
+};
+var hardhat = {
+  id: chainId.hardhat,
+  name: "Hardhat",
+  network: "hardhat",
+  rpcUrls: {
+    default: "http://127.0.0.1:8545"
+  }
+};
+var foundry = {
+  id: chainId.foundry,
+  name: "Foundry",
+  network: "foundry",
+  rpcUrls: {
+    default: "http://127.0.0.1:8545"
+  }
+};
+var chain = {
+  mainnet,
+  goerli,
+  sepolia,
+  optimism,
+  optimismGoerli,
+  polygon,
+  polygonMumbai,
+  arbitrum,
+  arbitrumGoerli,
+  localhost,
+  hardhat,
+  foundry
+};
+var allChains = [
+  mainnet,
+  goerli,
+  sepolia,
+  optimism,
+  optimismGoerli,
+  polygon,
+  polygonMumbai,
+  arbitrum,
+  arbitrumGoerli,
+  localhost,
+  hardhat,
+  foundry
+];
+var defaultChains = [mainnet, goerli];
+var defaultL2Chains = [
+  arbitrum,
+  arbitrumGoerli,
+  optimism,
+  optimismGoerli
+];
+
+export {
+  etherscanBlockExplorers,
+  alchemyRpcUrls,
+  infuraRpcUrls,
+  publicRpcUrls,
+  chainId,
+  mainnet,
+  goerli,
+  sepolia,
+  optimism,
+  optimismGoerli,
+  polygon,
+  polygonMumbai,
+  arbitrum,
+  arbitrumGoerli,
+  localhost,
+  hardhat,
+  foundry,
+  chain,
+  allChains,
+  defaultChains,
+  defaultL2Chains
+};

package/dist/chunk-MQXBDTVK.js

@@ -0,0 +1,29 @@
+var __accessCheck = (obj, member, msg) => {
+  if (!member.has(obj))
+    throw TypeError("Cannot " + msg);
+};
+var __privateGet = (obj, member, getter) => {
+  __accessCheck(obj, member, "read from private field");
+  return getter ? getter.call(obj) : member.get(obj);
+};
+var __privateAdd = (obj, member, value) => {
+  if (member.has(obj))
+    throw TypeError("Cannot add the same private member more than once");
+  member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
+};
+var __privateSet = (obj, member, value, setter) => {
+  __accessCheck(obj, member, "write to private field");
+  setter ? setter.call(obj, value) : member.set(obj, value);
+  return value;
+};
+var __privateMethod = (obj, member, method) => {
+  __accessCheck(obj, member, "access private method");
+  return method;
+};
+
+export {
+  __privateGet,
+  __privateAdd,
+  __privateSet,
+  __privateMethod
+};

package/dist/{declarations/src/connectors → connectors}/coinbaseWallet.d.ts

@@ -1,8 +1,11 @@
-import type { CoinbaseWalletProvider } from '@coinbase/wallet-sdk';
-import type { CoinbaseWalletSDKOptions } from '@coinbase/wallet-sdk/dist/CoinbaseWalletSDK';
+import { CoinbaseWalletProvider } from '@coinbase/wallet-sdk';
+import { CoinbaseWalletSDKOptions } from '@coinbase/wallet-sdk/dist/CoinbaseWalletSDK';
 import { providers } from 'ethers';
-import { Chain } from '../types';
-import { Connector } from './base';
+import { C as Chain } from '../index-bacc1c49.js';
+import { C as Connector } from '../base-5bd9b5ed.js';
+import 'abitype';
+import 'eventemitter3';
+
 declare type Options = CoinbaseWalletSDKOptions & {
     /**
      * Fallback Ethereum JSON RPC URL
@@ -15,7 +18,7 @@ declare type Options = CoinbaseWalletSDKOptions & {
      */
     chainId?: number;
 };
-export declare class CoinbaseWalletConnector extends Connector<CoinbaseWalletProvider, Options, providers.JsonRpcSigner> {
+declare class CoinbaseWalletConnector extends Connector<CoinbaseWalletProvider, Options, providers.JsonRpcSigner> {
     #private;
     readonly id = "coinbaseWallet";
     readonly name = "Coinbase Wallet";
@@ -53,4 +56,5 @@ export declare class CoinbaseWalletConnector extends Connector<CoinbaseWalletPro
     protected onChainChanged: (chainId: number | string) => void;
     protected onDisconnect: () => void;
 }
-export {};
+
+export { CoinbaseWalletConnector };

package/dist/connectors/coinbaseWallet.js

@@ -0,0 +1,215 @@
+import {
+  AddChainError,
+  ChainNotConfiguredError,
+  Connector,
+  SwitchChainError,
+  UserRejectedRequestError,
+  normalizeChainId
+} from "../chunk-2EDVJWOA.js";
+import "../chunk-4DNFSL2K.js";
+import {
+  __privateAdd,
+  __privateGet,
+  __privateMethod,
+  __privateSet
+} from "../chunk-MQXBDTVK.js";
+
+// src/connectors/coinbaseWallet.ts
+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);
+    this.id = "coinbaseWallet";
+    this.name = "Coinbase Wallet";
+    this.ready = true;
+    __privateAdd(this, _client, void 0);
+    __privateAdd(this, _provider, void 0);
+    this.onAccountsChanged = (accounts) => {
+      if (accounts.length === 0)
+        this.emit("disconnect");
+      else
+        this.emit("change", { account: getAddress(accounts[0]) });
+    };
+    this.onChainChanged = (chainId) => {
+      const id = normalizeChainId(chainId);
+      const unsupported = this.isChainUnsupported(id);
+      this.emit("change", { chain: { id, unsupported } });
+    };
+    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;
+      __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}`,
+        rpcUrls: { default: "" }
+      };
+    } 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 ?? chain.rpcUrls.default],
+                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/{declarations/src/connectors → connectors}/metaMask.d.ts

@@ -1,12 +1,17 @@
-import { Chain, Ethereum } from '../types';
-import { InjectedConnector, InjectedConnectorOptions } from './injected';
-export declare type MetaMaskConnectorOptions = Pick<InjectedConnectorOptions, 'shimChainChangedDisconnect' | 'shimDisconnect'> & {
+import { C as Chain, E as Ethereum } from '../index-bacc1c49.js';
+import { a as InjectedConnectorOptions, I as InjectedConnector } from '../injected-6980e5c3.js';
+import 'abitype';
+import 'ethers';
+import '../base-5bd9b5ed.js';
+import 'eventemitter3';
+
+declare 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.
      */
     UNSTABLE_shimOnConnectSelectAccount?: boolean;
 };
-export declare class MetaMaskConnector extends InjectedConnector {
+declare class MetaMaskConnector extends InjectedConnector {
     #private;
     readonly id = "metaMask";
     readonly ready: boolean;
@@ -26,3 +31,5 @@ export declare class MetaMaskConnector extends InjectedConnector {
     }>;
     getProvider(): Promise<Ethereum | undefined>;
 }
+
+export { MetaMaskConnector, MetaMaskConnectorOptions };