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

package/dist/base-b052e615.esm.js

@@ -0,0 +1,516 @@
+import EventEmitter from 'eventemitter3';
+
+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: 'Ethereum',
+    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',
+    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',
+    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 {
+  /** 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);
+  }
+
+}
+
+export { AddChainError as A, Connector as C, SwitchChainError as S, UserRejectedRequestError as U, _defineProperty as _, _classPrivateFieldInitSpec as a, ConnectorNotFoundError as b, _classPrivateFieldSet as c, _classPrivateFieldGet as d, allChains as e, ChainNotConfiguredError as f, ConnectorAlreadyConnectedError as g, SwitchChainNotSupportedError as h, alchemyRpcUrls as i, chain as j, chainId as k, defaultChains as l, defaultL2Chains as m, normalizeChainId as n, etherscanBlockExplorers as o, infuraRpcUrls as p, _checkPrivateRedeclaration as q };

package/dist/{classPrivateMethodGet-38b54c7a.cjs.dev.js → classPrivateMethodGet-45a38143.cjs.dev.js}

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

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

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

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

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

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

@@ -1,7 +1,16 @@
+import type { 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/fetchBalance.d.ts

@@ -3,6 +3,8 @@ import { Unit } from '../../types';
 export declare type FetchBalanceArgs = {
     /** Address or ENS name */
     addressOrName: string;
+    /** Chain id to use for provider */
+    chainId?: number;
     /** Units for formatting output */
     formatUnits?: Unit | number;
     /** ERC-20 address */
@@ -15,4 +17,4 @@ export declare type FetchBalanceResult = {
     unit: Unit | number;
     value: BigNumber;
 };
-export declare function fetchBalance({ addressOrName, formatUnits: unit, token, }: FetchBalanceArgs): Promise<FetchBalanceResult>;
+export declare function fetchBalance({ addressOrName, chainId, formatUnits: unit, token, }: FetchBalanceArgs): Promise<FetchBalanceResult>;

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

@@ -1,6 +1,7 @@
+import type { 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 type { 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/contracts/readContract.d.ts

@@ -5,7 +5,10 @@ export declare type ReadContractArgs = GetContractArgs;
 export declare type ReadContractConfig = {
     /** Arguments to pass contract method */
     args?: any | any[];
+    /** Chain id to use for provider */
+    chainId?: number;
+    /** Call overrides */
     overrides?: CallOverrides;
 };
 export declare type ReadContractResult = Result;
-export declare function readContract<Contract extends EthersContract = EthersContract>(contractConfig: ReadContractArgs, functionName: string, { args, overrides }?: ReadContractConfig): Promise<Result>;
+export declare function readContract<Contract extends EthersContract = EthersContract>(contractConfig: ReadContractArgs, functionName: string, { args, chainId, overrides }?: ReadContractConfig): Promise<Result>;

package/dist/declarations/src/actions/contracts/watchContractEvent.d.ts

@@ -1,6 +1,8 @@
 import { Contract as EthersContract } from 'ethers/lib/ethers';
 import { GetContractArgs } from './getContract';
 declare type Config = {
+    /** Chain id to use for provider */
+    chainId?: number;
     /** Receive only a single event */
     once?: boolean;
 };
@@ -8,5 +10,5 @@ export declare function watchContractEvent<Contract extends EthersContract = Eth
 /** Contract configuration */
 contractArgs: GetContractArgs, 
 /** Event name to listen to */
-eventName: Parameters<Contract['on']>[0], callback: Parameters<Contract['on']>[1], { once }?: Config): () => void;
+eventName: Parameters<Contract['on']>[0], callback: Parameters<Contract['on']>[1], { chainId, once }?: Config): () => void;
 export {};

package/dist/declarations/src/actions/ens/fetchEnsAddress.d.ts

@@ -1,6 +1,8 @@
 export declare type FetchEnsAddressArgs = {
+    /** Chain id to use for provider */
+    chainId?: number;
     /** ENS name to resolve */
     name: string;
 };
 export declare type FetchEnsAddressResult = string | null;
-export declare function fetchEnsAddress({ name, }: FetchEnsAddressArgs): Promise<FetchEnsAddressResult>;
+export declare function fetchEnsAddress({ chainId, name, }: FetchEnsAddressArgs): Promise<FetchEnsAddressResult>;

package/dist/declarations/src/actions/ens/fetchEnsAvatar.d.ts

@@ -1,6 +1,8 @@
 export declare type FetchEnsAvatarArgs = {
     /** Address or ENS name */
     addressOrName: string;
+    /** Chain id to use for provider */
+    chainId?: number;
 };
 export declare type FetchEnsAvatarResult = string | null;
-export declare function fetchEnsAvatar({ addressOrName, }: FetchEnsAvatarArgs): Promise<FetchEnsAvatarResult>;
+export declare function fetchEnsAvatar({ addressOrName, chainId, }: FetchEnsAvatarArgs): Promise<FetchEnsAvatarResult>;

package/dist/declarations/src/actions/ens/fetchEnsName.d.ts

@@ -1,6 +1,8 @@
 export declare type FetchEnsNameArgs = {
     /** Address to lookup */
     address: string;
+    /** Chain id to use for provider */
+    chainId?: number;
 };
 export declare type FetchEnsNameResult = string | null;
-export declare function fetchEnsName({ address, }: FetchEnsNameArgs): Promise<FetchEnsNameResult>;
+export declare function fetchEnsName({ address, chainId, }: FetchEnsNameArgs): Promise<FetchEnsNameResult>;

package/dist/declarations/src/actions/ens/fetchEnsResolver.d.ts

@@ -1,7 +1,9 @@
 import type { Resolver } from '@ethersproject/providers';
 export declare type FetchEnsResolverArgs = {
+    /** Chain id to use for provider */
+    chainId?: number;
     /** ENS name to resolve */
     name: string;
 };
 export declare type FetchEnsResolverResult = Resolver | null;
-export declare function fetchEnsResolver({ name, }: FetchEnsResolverArgs): Promise<FetchEnsResolverResult>;
+export declare function fetchEnsResolver({ chainId, name, }: FetchEnsResolverArgs): Promise<FetchEnsResolverResult>;