@wagmi/core 0.2.0-next.1 → 0.2.0-next.10

package/dist/base-d3563329.cjs.prod.js

@@ -0,0 +1,543 @@
+'use strict';
+
+var EventEmitter = require('eventemitter3');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { 'default': e }; }
+
+var EventEmitter__default = /*#__PURE__*/_interopDefault(EventEmitter);
+
+function _checkPrivateRedeclaration(obj, privateCollection) {
+  if (privateCollection.has(obj)) {
+    throw new TypeError("Cannot initialize the same private elements twice on an object");
+  }
+}
+
+function _classPrivateFieldInitSpec(obj, privateMap, value) {
+  _checkPrivateRedeclaration(obj, privateMap);
+  privateMap.set(obj, value);
+}
+
+function _defineProperty(obj, key, value) {
+  if (key in obj) {
+    Object.defineProperty(obj, key, {
+      value: value,
+      enumerable: true,
+      configurable: true,
+      writable: true
+    });
+  } else {
+    obj[key] = value;
+  }
+
+  return obj;
+}
+
+function _classApplyDescriptorGet(receiver, descriptor) {
+  if (descriptor.get) {
+    return descriptor.get.call(receiver);
+  }
+
+  return descriptor.value;
+}
+
+function _classExtractFieldDescriptor(receiver, privateMap, action) {
+  if (!privateMap.has(receiver)) {
+    throw new TypeError("attempted to " + action + " private field on non-instance");
+  }
+
+  return privateMap.get(receiver);
+}
+
+function _classPrivateFieldGet(receiver, privateMap) {
+  var descriptor = _classExtractFieldDescriptor(receiver, privateMap, "get");
+  return _classApplyDescriptorGet(receiver, descriptor);
+}
+
+function _classApplyDescriptorSet(receiver, descriptor, value) {
+  if (descriptor.set) {
+    descriptor.set.call(receiver, value);
+  } else {
+    if (!descriptor.writable) {
+      throw new TypeError("attempted to set read only private field");
+    }
+
+    descriptor.value = value;
+  }
+}
+
+function _classPrivateFieldSet(receiver, privateMap, value) {
+  var descriptor = _classExtractFieldDescriptor(receiver, privateMap, "set");
+  _classApplyDescriptorSet(receiver, descriptor, value);
+  return value;
+}
+
+const etherscanBlockExplorers = {
+  mainnet: {
+    name: 'Etherscan',
+    url: 'https://etherscan.io'
+  },
+  ropsten: {
+    name: 'Etherscan',
+    url: 'https://ropsten.etherscan.io'
+  },
+  rinkeby: {
+    name: 'Etherscan',
+    url: 'https://rinkeby.etherscan.io'
+  },
+  goerli: {
+    name: 'Etherscan',
+    url: 'https://goerli.etherscan.io'
+  },
+  kovan: {
+    name: 'Etherscan',
+    url: 'https://kovan.etherscan.io'
+  },
+  optimism: {
+    name: 'Etherscan',
+    url: 'https://optimistic.etherscan.io'
+  },
+  optimismKovan: {
+    name: 'Etherscan',
+    url: 'https://kovan-optimistic.etherscan.io'
+  },
+  polygon: {
+    name: 'PolygonScan',
+    url: 'https://polygonscan.com'
+  },
+  polygonMumbai: {
+    name: 'PolygonScan',
+    url: 'https://mumbai.polygonscan.com'
+  },
+  arbitrum: {
+    name: 'Arbiscan',
+    url: 'https://arbiscan.io'
+  },
+  arbitrumRinkeby: {
+    name: 'Arbiscan',
+    url: 'https://testnet.arbiscan.io'
+  }
+};
+
+const defaultAlchemyId = '_gg7wSSi0KMBsdKnGVfHDueq6xMB9EkC';
+
+const alchemyRpcUrls = {
+  mainnet: 'https://eth-mainnet.alchemyapi.io/v2',
+  ropsten: 'https://eth-ropsten.alchemyapi.io/v2',
+  rinkeby: 'https://eth-rinkeby.alchemyapi.io/v2',
+  goerli: 'https://eth-goerli.alchemyapi.io/v2',
+  kovan: 'https://eth-kovan.alchemyapi.io/v2',
+  optimism: 'https://opt-mainnet.g.alchemy.com/v2',
+  optimismKovan: 'https://opt-kovan.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',
+  arbitrumRinkeby: 'https://arb-rinkeby.g.alchemy.com/v2'
+};
+const infuraRpcUrls = {
+  mainnet: 'https://mainnet.infura.io/v3',
+  ropsten: 'https://ropsten.infura.io/v3',
+  rinkeby: 'https://rinkeby.infura.io/v3',
+  goerli: 'https://goerli.infura.io/v3',
+  kovan: 'https://kovan.infura.io/v3',
+  optimism: 'https://optimism-mainnet.infura.io/v3',
+  optimismKovan: 'https://optimism-kovan.infura.io/v3',
+  polygon: 'https://polygon-mainnet.infura.io/v3',
+  polygonMumbai: 'https://polygon-mumbai.infura.io/v3',
+  arbitrum: 'https://arbitrum-mainnet.infura.io/v3',
+  arbitrumRinkeby: 'https://arbitrum-rinkeby.infura.io/v3'
+};
+
+const chainId = {
+  mainnet: 1,
+  ropsten: 3,
+  rinkeby: 4,
+  goerli: 5,
+  kovan: 42,
+  optimism: 10,
+  optimismKovan: 69,
+  polygon: 137,
+  polygonMumbai: 80001,
+  arbitrum: 42161,
+  arbitrumRinkeby: 421611,
+  localhost: 1337,
+  hardhat: 31337
+};
+const chain = {
+  mainnet: {
+    id: chainId.mainnet,
+    name: 'Mainnet',
+    nativeCurrency: {
+      name: 'Ether',
+      symbol: 'ETH',
+      decimals: 18
+    },
+    rpcUrls: {
+      alchemy: alchemyRpcUrls.mainnet,
+      infura: infuraRpcUrls.mainnet,
+      default: "".concat(alchemyRpcUrls.mainnet, "/").concat(defaultAlchemyId)
+    },
+    blockExplorers: {
+      etherscan: etherscanBlockExplorers.mainnet,
+      default: etherscanBlockExplorers.mainnet
+    }
+  },
+  ropsten: {
+    id: chainId.ropsten,
+    name: 'Ropsten',
+    nativeCurrency: {
+      name: 'Ropsten Ether',
+      symbol: 'ropETH',
+      decimals: 18
+    },
+    rpcUrls: {
+      alchemy: alchemyRpcUrls.ropsten,
+      infura: infuraRpcUrls.ropsten,
+      default: "".concat(alchemyRpcUrls.ropsten, "/").concat(defaultAlchemyId)
+    },
+    blockExplorers: {
+      etherscan: etherscanBlockExplorers.ropsten,
+      default: etherscanBlockExplorers.ropsten
+    },
+    testnet: true
+  },
+  rinkeby: {
+    id: chainId.rinkeby,
+    name: 'Rinkeby',
+    nativeCurrency: {
+      name: 'Rinkeby Ether',
+      symbol: 'rETH',
+      decimals: 18
+    },
+    rpcUrls: {
+      alchemy: alchemyRpcUrls.rinkeby,
+      infura: infuraRpcUrls.rinkeby,
+      default: "".concat(alchemyRpcUrls.rinkeby, "/").concat(defaultAlchemyId)
+    },
+    blockExplorers: {
+      etherscan: etherscanBlockExplorers.rinkeby,
+      default: etherscanBlockExplorers.rinkeby
+    },
+    testnet: true
+  },
+  goerli: {
+    id: chainId.goerli,
+    name: 'Goerli',
+    nativeCurrency: {
+      name: 'Goerli Ether',
+      symbol: 'gETH',
+      decimals: 18
+    },
+    rpcUrls: {
+      alchemy: alchemyRpcUrls.goerli,
+      infura: infuraRpcUrls.goerli,
+      default: "".concat(alchemyRpcUrls.goerli, "/").concat(defaultAlchemyId)
+    },
+    blockExplorers: {
+      etherscan: etherscanBlockExplorers.goerli,
+      default: etherscanBlockExplorers.goerli
+    },
+    testnet: true
+  },
+  kovan: {
+    id: chainId.kovan,
+    name: 'Kovan',
+    nativeCurrency: {
+      name: 'Kovan Ether',
+      symbol: 'kETH',
+      decimals: 18
+    },
+    rpcUrls: {
+      alchemy: alchemyRpcUrls.kovan,
+      infura: infuraRpcUrls.kovan,
+      default: "".concat(alchemyRpcUrls.kovan, "/").concat(defaultAlchemyId)
+    },
+    blockExplorers: {
+      etherscan: etherscanBlockExplorers.kovan,
+      default: etherscanBlockExplorers.kovan
+    },
+    testnet: true
+  },
+  optimism: {
+    id: chainId.optimism,
+    name: 'Optimism',
+    nativeCurrency: {
+      name: 'Ether',
+      symbol: 'ETH',
+      decimals: 18
+    },
+    rpcUrls: {
+      alchemy: alchemyRpcUrls.optimism,
+      infura: infuraRpcUrls.optimism,
+      default: ['https://mainnet.optimism.io']
+    },
+    blockExplorers: {
+      etherscan: etherscanBlockExplorers.optimism,
+      default: etherscanBlockExplorers.optimism
+    }
+  },
+  optimismKovan: {
+    id: chainId.optimismKovan,
+    name: 'Optimism Kovan',
+    nativeCurrency: {
+      name: 'Kovan Ether',
+      symbol: 'KOR',
+      decimals: 18
+    },
+    rpcUrls: {
+      alchemy: alchemyRpcUrls.optimismKovan,
+      infura: infuraRpcUrls.optimismKovan,
+      default: ['https://kovan.optimism.io']
+    },
+    blockExplorers: {
+      etherscan: etherscanBlockExplorers.optimismKovan,
+      default: etherscanBlockExplorers.optimismKovan
+    },
+    testnet: true
+  },
+  polygon: {
+    id: chainId.polygon,
+    name: 'Polygon Mainnet',
+    nativeCurrency: {
+      name: 'MATIC',
+      symbol: 'MATIC',
+      decimals: 18
+    },
+    rpcUrls: {
+      alchemy: alchemyRpcUrls.polygon,
+      infura: infuraRpcUrls.polygon,
+      default: ['https://polygon-rpc.com', 'https://rpc-mainnet.matic.network', 'https://matic-mainnet.chainstacklabs.com', 'https://rpc-mainnet.maticvigil.com', 'https://rpc-mainnet.matic.quiknode.pro', 'https://matic-mainnet-full-rpc.bwarelabs.com']
+    },
+    blockExplorers: {
+      etherscan: etherscanBlockExplorers.polygon,
+      default: etherscanBlockExplorers.polygon
+    }
+  },
+  polygonMumbai: {
+    id: chainId.polygonMumbai,
+    name: 'Mumbai',
+    nativeCurrency: {
+      name: 'MATIC',
+      symbol: 'MATIC',
+      decimals: 18
+    },
+    rpcUrls: {
+      alchemy: alchemyRpcUrls.polygonMumbai,
+      infura: infuraRpcUrls.polygonMumbai,
+      default: ['https://matic-mumbai.chainstacklabs.com', 'https://rpc-mumbai.maticvigil.com', 'https://matic-testnet-archive-rpc.bwarelabs.com']
+    },
+    blockExplorers: {
+      etherscan: etherscanBlockExplorers.polygonMumbai,
+      default: etherscanBlockExplorers.polygonMumbai
+    },
+    testnet: true
+  },
+  arbitrum: {
+    id: chainId.arbitrum,
+    name: 'Arbitrum One',
+    nativeCurrency: {
+      name: 'Ether',
+      symbol: 'AETH',
+      decimals: 18
+    },
+    rpcUrls: {
+      alchemy: alchemyRpcUrls.arbitrum,
+      infura: infuraRpcUrls.arbitrum,
+      default: ['https://arb1.arbitrum.io/rpc']
+    },
+    blockExplorers: {
+      etherscan: etherscanBlockExplorers.arbitrum,
+      default: [etherscanBlockExplorers.arbitrum, {
+        name: 'Arbitrum Explorer',
+        url: 'https://explorer.arbitrum.io'
+      }]
+    }
+  },
+  arbitrumRinkeby: {
+    id: chainId.arbitrumRinkeby,
+    name: 'Arbitrum Rinkeby',
+    nativeCurrency: {
+      name: 'Arbitrum Rinkeby Ether',
+      symbol: 'ARETH',
+      decimals: 18
+    },
+    rpcUrls: {
+      alchemy: alchemyRpcUrls.arbitrumRinkeby,
+      infura: infuraRpcUrls.arbitrumRinkeby,
+      default: ['https://rinkeby.arbitrum.io/rpc']
+    },
+    blockExplorers: {
+      etherscan: etherscanBlockExplorers.arbitrumRinkeby,
+      default: [etherscanBlockExplorers.arbitrumRinkeby, {
+        name: 'Arbitrum Explorer',
+        url: 'https://rinkeby-explorer.arbitrum.io'
+      }]
+    },
+    testnet: true
+  },
+  localhost: {
+    id: chainId.localhost,
+    name: 'Localhost',
+    rpcUrls: {
+      default: 'http://127.0.0.1:8545'
+    }
+  },
+  hardhat: {
+    id: chainId.hardhat,
+    name: 'Hardhat',
+    rpcUrls: {
+      default: 'http://127.0.0.1:8545'
+    }
+  }
+};
+const allChains = Object.values(chain);
+const defaultChains = [chain.mainnet, chain.ropsten, chain.rinkeby, chain.goerli, chain.kovan];
+const defaultL2Chains = [chain.arbitrum, chain.arbitrumRinkeby, chain.optimism, chain.optimismKovan];
+
+function normalizeChainId(chainId) {
+  if (typeof chainId === 'string') return Number.parseInt(chainId, chainId.trim().substring(0, 2) === '0x' ? 16 : 10);
+  return chainId;
+}
+
+class AddChainError extends Error {
+  constructor() {
+    super(...arguments);
+
+    _defineProperty(this, "name", 'AddChainError');
+
+    _defineProperty(this, "message", 'Error adding chain');
+  }
+
+}
+class ChainNotConfiguredError extends Error {
+  constructor() {
+    super(...arguments);
+
+    _defineProperty(this, "name", 'ChainNotConfigured');
+
+    _defineProperty(this, "message", 'Chain not configured');
+  }
+
+}
+class ConnectorAlreadyConnectedError extends Error {
+  constructor() {
+    super(...arguments);
+
+    _defineProperty(this, "name", 'ConnectorAlreadyConnectedError');
+
+    _defineProperty(this, "message", 'Connector already connected');
+  }
+
+}
+class ConnectorNotFoundError extends Error {
+  constructor() {
+    super(...arguments);
+
+    _defineProperty(this, "name", 'ConnectorNotFoundError');
+
+    _defineProperty(this, "message", 'Connector not found');
+  }
+
+}
+class SwitchChainError extends Error {
+  constructor() {
+    super(...arguments);
+
+    _defineProperty(this, "name", 'SwitchChainError');
+
+    _defineProperty(this, "message", 'Error switching chain');
+  }
+
+}
+class SwitchChainNotSupportedError extends Error {
+  constructor() {
+    super(...arguments);
+
+    _defineProperty(this, "name", 'SwitchChainNotSupportedError');
+
+    _defineProperty(this, "message", 'Switch chain not supported by connector');
+  }
+
+}
+class UserRejectedRequestError extends Error {
+  constructor() {
+    super(...arguments);
+
+    _defineProperty(this, "name", 'UserRejectedRequestError');
+
+    _defineProperty(this, "message", 'User rejected request');
+  }
+
+}
+
+class Connector extends EventEmitter__default["default"] {
+  /** Unique connector id */
+
+  /** Connector name */
+
+  /** Chains connector supports */
+
+  /** Options to use with connector */
+
+  /** Whether connector is usable */
+  constructor(_ref) {
+    let {
+      chains = defaultChains,
+      options
+    } = _ref;
+    super();
+
+    _defineProperty(this, "id", void 0);
+
+    _defineProperty(this, "name", void 0);
+
+    _defineProperty(this, "chains", void 0);
+
+    _defineProperty(this, "options", void 0);
+
+    _defineProperty(this, "ready", void 0);
+
+    this.chains = chains;
+    this.options = options;
+  }
+
+  getBlockExplorerUrls(chain) {
+    var _chain$blockExplorers;
+
+    const blockExplorer = (_chain$blockExplorers = chain.blockExplorers) === null || _chain$blockExplorers === void 0 ? void 0 : _chain$blockExplorers.default;
+    if (Array.isArray(blockExplorer)) return blockExplorer.map(x => x.url);
+    if (blockExplorer !== null && blockExplorer !== void 0 && blockExplorer.url) return [blockExplorer.url];
+    return [];
+  }
+
+  getRpcUrls(chain) {
+    return typeof chain.rpcUrls.default === 'string' ? [chain.rpcUrls.default] : chain.rpcUrls.default;
+  }
+
+  isChainUnsupported(chainId) {
+    return !this.chains.some(x => x.id === chainId);
+  }
+
+}
+
+exports.AddChainError = AddChainError;
+exports.ChainNotConfiguredError = ChainNotConfiguredError;
+exports.Connector = Connector;
+exports.ConnectorAlreadyConnectedError = ConnectorAlreadyConnectedError;
+exports.ConnectorNotFoundError = ConnectorNotFoundError;
+exports.SwitchChainError = SwitchChainError;
+exports.SwitchChainNotSupportedError = SwitchChainNotSupportedError;
+exports.UserRejectedRequestError = UserRejectedRequestError;
+exports._checkPrivateRedeclaration = _checkPrivateRedeclaration;
+exports._classPrivateFieldGet = _classPrivateFieldGet;
+exports._classPrivateFieldInitSpec = _classPrivateFieldInitSpec;
+exports._classPrivateFieldSet = _classPrivateFieldSet;
+exports._defineProperty = _defineProperty;
+exports.alchemyRpcUrls = alchemyRpcUrls;
+exports.allChains = allChains;
+exports.chain = chain;
+exports.chainId = chainId;
+exports.defaultChains = defaultChains;
+exports.defaultL2Chains = defaultL2Chains;
+exports.etherscanBlockExplorers = etherscanBlockExplorers;
+exports.infuraRpcUrls = infuraRpcUrls;
+exports.normalizeChainId = normalizeChainId;

package/dist/{classPrivateMethodGet-38b54c7a.cjs.dev.js → classPrivateMethodGet-3f47cf74.cjs.dev.js}

@@ -1,6 +1,6 @@
 'use strict';
 
-var base = require('./base-09a653f3.cjs.dev.js');
+var base = require('./base-85d1eb89.cjs.dev.js');
 
 function _classPrivateMethodInitSpec(obj, privateSet) {
   base._checkPrivateRedeclaration(obj, privateSet);

package/dist/{classPrivateMethodGet-0e9a7925.cjs.prod.js → classPrivateMethodGet-a763c0df.cjs.prod.js}

@@ -1,6 +1,6 @@
 'use strict';
 
-var base = require('./base-d8123d5f.cjs.prod.js');
+var base = require('./base-d3563329.cjs.prod.js');
 
 function _classPrivateMethodInitSpec(obj, privateSet) {
   base._checkPrivateRedeclaration(obj, privateSet);

package/dist/{classPrivateMethodGet-c9db96d6.esm.js → classPrivateMethodGet-b3ba7c1d.esm.js}

@@ -1,4 +1,4 @@
-import { l as _checkPrivateRedeclaration } from './base-824c3b6d.esm.js';
+import { q as _checkPrivateRedeclaration } from './base-37097073.esm.js';
 
 function _classPrivateMethodInitSpec(obj, privateSet) {
   _checkPrivateRedeclaration(obj, privateSet);

package/dist/declarations/src/actions/accounts/connect.d.ts

@@ -1,7 +1,16 @@
+import { BaseProvider } from '@ethersproject/providers';
 import { Client } from '../../client';
-import { Connector } from '../../connectors';
-export declare type ConnectResult = {
-    data: Client['data'];
-    connector: Client['connector'];
+import { Connector, ConnectorData } from '../../connectors';
+export declare type ConnectArgs = {
+    /** Connector to connect */
+    connector: Connector;
 };
-export declare function connect(connector: Connector): Promise<ConnectResult>;
+declare type Data<TProvider extends BaseProvider = BaseProvider> = Required<ConnectorData<TProvider>>;
+export declare type ConnectResult<TProvider extends BaseProvider = BaseProvider> = {
+    account: Data<TProvider>['account'];
+    chain: Data<TProvider>['chain'];
+    connector: Client<TProvider>['connector'];
+    provider: Data<TProvider>['provider'];
+};
+export declare function connect<TProvider extends BaseProvider>({ connector, }: ConnectArgs): Promise<ConnectResult<TProvider>>;
+export {};

package/dist/declarations/src/actions/accounts/getAccount.d.ts

@@ -1,6 +1,7 @@
+import { BaseProvider } from '@ethersproject/providers';
 import { Client, Data } from '../../client';
-export declare type GetAccountResult = {
-    address?: Data['account'];
-    connector?: Client['connector'];
+export declare type GetAccountResult<TProvider extends BaseProvider = BaseProvider> = {
+    address?: Data<TProvider>['account'];
+    connector?: Client<TProvider>['connector'];
 };
-export declare function getAccount(): GetAccountResult;
+export declare function getAccount<TProvider extends BaseProvider>(): GetAccountResult<TProvider>;

package/dist/declarations/src/actions/accounts/index.d.ts

@@ -1,4 +1,4 @@
-export { connect, type ConnectResult } from './connect';
+export { connect, type ConnectArgs, type ConnectResult } from './connect';
 export { disconnect } from './disconnect';
 export { fetchBalance, type FetchBalanceArgs, type FetchBalanceResult, } from './fetchBalance';
 export { fetchSigner, type FetchSignerResult } from './fetchSigner';

package/dist/declarations/src/actions/accounts/switchNetwork.d.ts

@@ -3,4 +3,4 @@ export declare type SwitchNetworkArgs = {
     chainId: number;
 };
 export declare type SwitchNetworkResult = Chain;
-export declare function switchNetwork(args: SwitchNetworkArgs): Promise<SwitchNetworkResult>;
+export declare function switchNetwork({ chainId, }: SwitchNetworkArgs): Promise<SwitchNetworkResult>;

package/dist/declarations/src/actions/accounts/watchAccount.d.ts

@@ -1,3 +1,4 @@
+import { BaseProvider } from '@ethersproject/providers';
 import { GetAccountResult } from './getAccount';
-export declare type WatchAccountCallback = (data: GetAccountResult) => void;
-export declare function watchAccount(callback: WatchAccountCallback): () => void;
+export declare type WatchAccountCallback<TProvider extends BaseProvider = BaseProvider> = (data: GetAccountResult<TProvider>) => void;
+export declare function watchAccount<TProvider extends BaseProvider>(callback: WatchAccountCallback<TProvider>): () => void;

package/dist/declarations/src/actions/index.d.ts

@@ -1,4 +1,4 @@
-export { connect, disconnect, fetchBalance, fetchSigner, getAccount, getNetwork, signMessage, signTypedData, switchNetwork, watchAccount, watchBalance, watchNetwork, watchSigner, type ConnectResult, type FetchBalanceArgs, type FetchBalanceResult, type FetchSignerResult, type GetAccountResult, type GetNetworkResult, type SignMessageArgs, type SignMessageResult, type SignTypedDataArgs, type SignTypedDataResult, type SwitchNetworkArgs, type SwitchNetworkResult, type WatchAccountCallback, type WatchBalanceCallback, type WatchNetworkCallback, type WatchSignerCallback, } from './accounts';
+export { connect, disconnect, fetchBalance, fetchSigner, getAccount, getNetwork, signMessage, signTypedData, switchNetwork, watchAccount, watchBalance, watchNetwork, watchSigner, type ConnectArgs, type ConnectResult, type FetchBalanceArgs, type FetchBalanceResult, type FetchSignerResult, type GetAccountResult, type GetNetworkResult, type SignMessageArgs, type SignMessageResult, type SignTypedDataArgs, type SignTypedDataResult, type SwitchNetworkArgs, type SwitchNetworkResult, type WatchAccountCallback, type WatchBalanceCallback, type WatchNetworkCallback, type WatchSignerCallback, } from './accounts';
 export { getContract, readContract, watchContractEvent, watchReadContract, writeContract, type GetContractArgs, type ReadContractArgs, type ReadContractConfig, type ReadContractResult, type WatchReadContractArgs, type WatchReadContractConfig, type WatchReadContractResult, type WriteContractArgs, type WriteContractConfig, type WriteContractResult, } from './contracts';
 export { fetchEnsAddress, fetchEnsAvatar, fetchEnsName, fetchEnsResolver, watchEnsAddress, watchEnsAvatar, watchEnsName, watchEnsResolver, type FetchEnsAddressArgs, type FetchEnsAddressResult, type FetchEnsAvatarArgs, type FetchEnsAvatarResult, type FetchEnsNameArgs, type FetchEnsNameResult, type FetchEnsResolverArgs, type FetchEnsResolverResult, type WatchEnsAddressCallback, type WatchEnsAvatarCallback, type WatchEnsNameCallback, type WatchEnsResolverCallback, } from './ens';
 export { fetchBlockNumber, fetchFeeData, watchBlockNumber, watchFeeData, type FetchBlockNumberResult, type FetchFeeDataArgs, type FetchFeeDataResult, type WatchBlockNumberArgs, type WatchBlockNumberCallback, type WatchFeeDataArgs, type WatchFeeDataCallback, } from './network-status';

package/dist/declarations/src/actions/providers/getProvider.d.ts

@@ -1,3 +1,3 @@
 import type { BaseProvider } from '@ethersproject/providers';
-export declare type GetProviderResult = BaseProvider;
-export declare function getProvider(): GetProviderResult;
+export declare type GetProviderResult<TProvider extends BaseProvider = BaseProvider> = TProvider;
+export declare function getProvider<TProvider extends BaseProvider = BaseProvider>(): GetProviderResult<TProvider>;

package/dist/declarations/src/actions/providers/getWebSocketProvider.d.ts

@@ -1,3 +1,3 @@
 import type { WebSocketProvider } from '@ethersproject/providers';
-export declare type GetWebSocketProviderResult = WebSocketProvider | undefined;
-export declare function getWebSocketProvider(): GetWebSocketProviderResult;
+export declare type GetWebSocketProviderResult<TWebSocketProvider extends WebSocketProvider = WebSocketProvider> = TWebSocketProvider | undefined;
+export declare function getWebSocketProvider<TWebSocketProvider extends WebSocketProvider = WebSocketProvider>(): GetWebSocketProviderResult<TWebSocketProvider>;

package/dist/declarations/src/actions/providers/watchProvider.d.ts

@@ -1,3 +1,4 @@
+import { BaseProvider } from '@ethersproject/providers';
 import { GetProviderResult } from './getProvider';
-export declare type WatchProviderCallback = (provider: GetProviderResult) => void;
-export declare function watchProvider(callback: WatchProviderCallback): () => void;
+export declare type WatchProviderCallback<TProvider extends BaseProvider = BaseProvider> = (provider: GetProviderResult<TProvider>) => void;
+export declare function watchProvider<TProvider extends BaseProvider = BaseProvider>(callback: WatchProviderCallback<TProvider>): () => void;

package/dist/declarations/src/actions/providers/watchWebSocketProvider.d.ts

@@ -1,3 +1,4 @@
+import type { WebSocketProvider } from '@ethersproject/providers';
 import { GetWebSocketProviderResult } from './getWebSocketProvider';
-export declare type WatchWebSocketProviderCallback = (webSocketProvider: GetWebSocketProviderResult) => void;
-export declare function watchWebSocketProvider(callback: WatchWebSocketProviderCallback): () => void;
+export declare type WatchWebSocketProviderCallback<TWebSocketProvider extends WebSocketProvider = WebSocketProvider> = (webSocketProvider: GetWebSocketProviderResult<TWebSocketProvider>) => void;
+export declare function watchWebSocketProvider<TWebSocketProvider extends WebSocketProvider = WebSocketProvider>(callback: WatchWebSocketProviderCallback<TWebSocketProvider>): () => void;