@wagmi/core 0.2.0-next.0

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

@@ -0,0 +1,453 @@
+'use strict';
+
+var EventEmitter = require('eventemitter3');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { 'default': e }; }
+
+var EventEmitter__default = /*#__PURE__*/_interopDefault(EventEmitter);
+
+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 asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
+  try {
+    var info = gen[key](arg);
+    var value = info.value;
+  } catch (error) {
+    reject(error);
+    return;
+  }
+
+  if (info.done) {
+    resolve(value);
+  } else {
+    Promise.resolve(value).then(_next, _throw);
+  }
+}
+
+function _asyncToGenerator(fn) {
+  return function () {
+    var self = this,
+        args = arguments;
+    return new Promise(function (resolve, reject) {
+      var gen = fn.apply(self, args);
+
+      function _next(value) {
+        asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value);
+      }
+
+      function _throw(err) {
+        asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err);
+      }
+
+      _next(undefined);
+    });
+  };
+}
+
+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 _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;
+}
+
+/**
+ * Data from Chainlist
+ * @see https://chainlist.org
+ */
+var chain = {
+  mainnet: {
+    id: 1,
+    name: 'Mainnet',
+    nativeCurrency: {
+      name: 'Ether',
+      symbol: 'ETH',
+      decimals: 18
+    },
+    rpcUrls: ['https://mainnet.infura.io/v3'],
+    blockExplorers: [{
+      name: 'Etherscan',
+      url: 'https://etherscan.io'
+    }]
+  },
+  ropsten: {
+    id: 3,
+    name: 'Ropsten',
+    nativeCurrency: {
+      name: 'Ropsten Ether',
+      symbol: 'ropETH',
+      decimals: 18
+    },
+    rpcUrls: ['https://ropsten.infura.io/v3'],
+    blockExplorers: [{
+      name: 'Etherscan',
+      url: 'https://ropsten.etherscan.io'
+    }],
+    testnet: true
+  },
+  rinkeby: {
+    id: 4,
+    name: 'Rinkeby',
+    nativeCurrency: {
+      name: 'Rinkeby Ether',
+      symbol: 'rETH',
+      decimals: 18
+    },
+    rpcUrls: ['https://rinkeby.infura.io/v3'],
+    blockExplorers: [{
+      name: 'Etherscan',
+      url: 'https://rinkeby.etherscan.io'
+    }],
+    testnet: true
+  },
+  goerli: {
+    id: 5,
+    name: 'Goerli',
+    nativeCurrency: {
+      name: 'Goerli Ether',
+      symbol: 'gETH',
+      decimals: 18
+    },
+    rpcUrls: ['https://goerli.infura.io/v3'],
+    blockExplorers: [{
+      name: 'Etherscan',
+      url: 'https://goerli.etherscan.io'
+    }],
+    testnet: true
+  },
+  kovan: {
+    id: 42,
+    name: 'Kovan',
+    nativeCurrency: {
+      name: 'Kovan Ether',
+      symbol: 'kETH',
+      decimals: 18
+    },
+    rpcUrls: ['https://kovan.infura.io/v3'],
+    blockExplorers: [{
+      name: 'Etherscan',
+      url: 'https://kovan.etherscan.io'
+    }],
+    testnet: true
+  },
+  optimism: {
+    id: 10,
+    name: 'Optimism',
+    nativeCurrency: {
+      name: 'Ether',
+      symbol: 'ETH',
+      decimals: 18
+    },
+    rpcUrls: ['https://mainnet.optimism.io'],
+    blockExplorers: [{
+      name: 'Etherscan',
+      url: 'https://optimistic.etherscan.io'
+    }]
+  },
+  optimismKovan: {
+    id: 69,
+    name: 'Optimism Kovan',
+    nativeCurrency: {
+      name: 'Kovan Ether',
+      symbol: 'KOR',
+      decimals: 18
+    },
+    rpcUrls: ['https://kovan.optimism.io'],
+    blockExplorers: [{
+      name: 'Etherscan',
+      url: 'https://kovan-optimistic.etherscan.io'
+    }],
+    testnet: true
+  },
+  polygonMainnet: {
+    id: 137,
+    name: 'Polygon Mainnet',
+    nativeCurrency: {
+      name: 'MATIC',
+      symbol: 'MATIC',
+      decimals: 18
+    },
+    rpcUrls: ['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: [{
+      name: 'Polygonscan',
+      url: 'https://polygonscan.com'
+    }]
+  },
+  polygonTestnetMumbai: {
+    id: 80001,
+    name: 'Mumbai',
+    nativeCurrency: {
+      name: 'MATIC',
+      symbol: 'MATIC',
+      decimals: 18
+    },
+    rpcUrls: ['https://matic-mumbai.chainstacklabs.com', 'https://rpc-mumbai.maticvigil.com', 'https://matic-testnet-archive-rpc.bwarelabs.com'],
+    blockExplorers: [{
+      name: 'Polygonscan',
+      url: 'https://mumbai.polygonscan.com'
+    }],
+    testnet: true
+  },
+  arbitrumOne: {
+    id: 42161,
+    name: 'Arbitrum One',
+    nativeCurrency: {
+      name: 'Ether',
+      symbol: 'AETH',
+      decimals: 18
+    },
+    rpcUrls: ['https://arb1.arbitrum.io/rpc'],
+    blockExplorers: [{
+      name: 'Arbiscan',
+      url: 'https://arbiscan.io'
+    }, {
+      name: 'Arbitrum Explorer',
+      url: 'https://explorer.arbitrum.io'
+    }]
+  },
+  arbitrumRinkeby: {
+    id: 421611,
+    name: 'Arbitrum Rinkeby',
+    nativeCurrency: {
+      name: 'Arbitrum Rinkeby Ether',
+      symbol: 'ARETH',
+      decimals: 18
+    },
+    rpcUrls: ['https://rinkeby.arbitrum.io/rpc'],
+    blockExplorers: [{
+      name: 'Arbitrum Explorer',
+      url: 'https://rinkeby-explorer.arbitrum.io'
+    }],
+    testnet: true
+  },
+  avalanche: {
+    id: 43114,
+    name: 'Avalanche Mainnet',
+    nativeCurrency: {
+      name: 'Avalanche',
+      symbol: 'AVAX',
+      decimals: 18
+    },
+    rpcUrls: ['https://api.avax.network/ext/bc/C/rpc'],
+    blockExplorers: [{
+      name: 'SnowTrace',
+      url: 'https://snowtrace.io'
+    }],
+    testnet: false
+  },
+  avalancheFuji: {
+    id: 43113,
+    name: 'Avalanche Fuji Testnet',
+    nativeCurrency: {
+      name: 'Avalanche',
+      symbol: 'AVAX',
+      decimals: 18
+    },
+    rpcUrls: ['https://api.avax-test.network/ext/bc/C/rpc'],
+    blockExplorers: [{
+      name: 'SnowTrace',
+      url: 'https://testnet.snowtrace.io'
+    }],
+    testnet: true
+  },
+  localhost: {
+    id: 1337,
+    name: 'Localhost',
+    rpcUrls: ['https://127.0.0.1:8545']
+  },
+  hardhat: {
+    id: 31337,
+    name: 'Hardhat',
+    rpcUrls: ['http://127.0.0.1:8545']
+  }
+};
+var allChains = Object.values(chain);
+var defaultChains = [chain.mainnet, chain.ropsten, chain.rinkeby, chain.goerli, chain.kovan];
+
+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) {
+    var {
+      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;
+  }
+
+  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._asyncToGenerator = _asyncToGenerator;
+exports._checkPrivateRedeclaration = _checkPrivateRedeclaration;
+exports._classPrivateFieldGet = _classPrivateFieldGet;
+exports._classPrivateFieldInitSpec = _classPrivateFieldInitSpec;
+exports._classPrivateFieldSet = _classPrivateFieldSet;
+exports._defineProperty = _defineProperty;
+exports.allChains = allChains;
+exports.chain = chain;
+exports.defaultChains = defaultChains;
+exports.normalizeChainId = normalizeChainId;

package/dist/classPrivateMethodGet-0e9a7925.cjs.prod.js

@@ -0,0 +1,19 @@
+'use strict';
+
+var base = require('./base-d8123d5f.cjs.prod.js');
+
+function _classPrivateMethodInitSpec(obj, privateSet) {
+  base._checkPrivateRedeclaration(obj, privateSet);
+  privateSet.add(obj);
+}
+
+function _classPrivateMethodGet(receiver, privateSet, fn) {
+  if (!privateSet.has(receiver)) {
+    throw new TypeError("attempted to get private field on non-instance");
+  }
+
+  return fn;
+}
+
+exports._classPrivateMethodGet = _classPrivateMethodGet;
+exports._classPrivateMethodInitSpec = _classPrivateMethodInitSpec;

package/dist/classPrivateMethodGet-38b54c7a.cjs.dev.js

@@ -0,0 +1,19 @@
+'use strict';
+
+var base = require('./base-09a653f3.cjs.dev.js');
+
+function _classPrivateMethodInitSpec(obj, privateSet) {
+  base._checkPrivateRedeclaration(obj, privateSet);
+  privateSet.add(obj);
+}
+
+function _classPrivateMethodGet(receiver, privateSet, fn) {
+  if (!privateSet.has(receiver)) {
+    throw new TypeError("attempted to get private field on non-instance");
+  }
+
+  return fn;
+}
+
+exports._classPrivateMethodGet = _classPrivateMethodGet;
+exports._classPrivateMethodInitSpec = _classPrivateMethodInitSpec;

package/dist/classPrivateMethodGet-c9db96d6.esm.js

@@ -0,0 +1,16 @@
+import { l as _checkPrivateRedeclaration } from './base-824c3b6d.esm.js';
+
+function _classPrivateMethodInitSpec(obj, privateSet) {
+  _checkPrivateRedeclaration(obj, privateSet);
+  privateSet.add(obj);
+}
+
+function _classPrivateMethodGet(receiver, privateSet, fn) {
+  if (!privateSet.has(receiver)) {
+    throw new TypeError("attempted to get private field on non-instance");
+  }
+
+  return fn;
+}
+
+export { _classPrivateMethodInitSpec as _, _classPrivateMethodGet as a };

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

@@ -0,0 +1,7 @@
+import { Client } from '../../client';
+import { Connector } from '../../connectors';
+export declare type ConnectResult = {
+    data: Client['data'];
+    connector: Client['connector'];
+};
+export declare function connect(connector: Connector): Promise<ConnectResult>;

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

@@ -0,0 +1 @@
+export declare function disconnect(): Promise<void>;

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

@@ -0,0 +1,18 @@
+import { BigNumber } from 'ethers/lib/ethers';
+import { Unit } from '../../types';
+export declare type FetchBalanceArgs = {
+    /** Address or ENS name */
+    addressOrName: string;
+    /** Units for formatting output */
+    formatUnits?: Unit | number;
+    /** ERC-20 address */
+    token?: string;
+};
+export declare type FetchBalanceResult = {
+    decimals: number;
+    formatted: string;
+    symbol: string;
+    unit: Unit | number;
+    value: BigNumber;
+};
+export declare function fetchBalance({ addressOrName, formatUnits: unit, token, }: FetchBalanceArgs): Promise<FetchBalanceResult>;

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

@@ -0,0 +1,3 @@
+import { Signer } from 'ethers/lib/ethers';
+export declare type FetchSignerResult = Signer | undefined;
+export declare function fetchSigner(): Promise<FetchSignerResult>;

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

@@ -0,0 +1,6 @@
+import { Client, Data } from '../../client';
+export declare type GetAccountResult = {
+    address?: Data['account'];
+    connector?: Client['connector'];
+};
+export declare function getAccount(): GetAccountResult;

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

@@ -0,0 +1,9 @@
+import { Chain } from '../../types';
+export declare type GetNetworkResult = {
+    chain?: Chain & {
+        id: number;
+        unsupported?: boolean;
+    };
+    chains?: Chain[];
+};
+export declare function getNetwork(): GetNetworkResult;

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

@@ -0,0 +1,13 @@
+export { connect, type ConnectResult } from './connect';
+export { disconnect } from './disconnect';
+export { fetchBalance, type FetchBalanceArgs, type FetchBalanceResult, } from './fetchBalance';
+export { fetchSigner, type FetchSignerResult } from './fetchSigner';
+export { getAccount, type GetAccountResult } from './getAccount';
+export { getNetwork, type GetNetworkResult } from './getNetwork';
+export { signMessage, type SignMessageArgs, type SignMessageResult, } from './signMessage';
+export { signTypedData, type SignTypedDataArgs, type SignTypedDataResult, } from './signTypedData';
+export { switchNetwork, type SwitchNetworkArgs, type SwitchNetworkResult, } from './switchNetwork';
+export { watchAccount, type WatchAccountCallback } from './watchAccount';
+export { watchBalance, type WatchBalanceCallback } from './watchBalance';
+export { watchNetwork, type WatchNetworkCallback } from './watchNetwork';
+export { watchSigner, type WatchSignerCallback } from './watchSigner';

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

@@ -0,0 +1,9 @@
+import { Bytes } from 'ethers/lib/utils';
+export declare type SignMessageArgs = {
+    /** Message to sign with wallet */
+    message: Bytes | string;
+};
+declare type Signature = string;
+export declare type SignMessageResult = Signature;
+export declare function signMessage(args: SignMessageArgs): Promise<SignMessageResult>;
+export {};

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

@@ -0,0 +1,13 @@
+import type { providers } from 'ethers';
+declare type SignTypedData = Parameters<providers.JsonRpcSigner['_signTypedData']>;
+export declare type SignTypedDataArgs = {
+    /** Domain or domain signature for origin or contract */
+    domain: SignTypedData[0];
+    /** Named list of all type definitions */
+    types: SignTypedData[1];
+    /** Data to sign */
+    value: SignTypedData[2];
+};
+export declare type SignTypedDataResult = string;
+export declare function signTypedData(args: SignTypedDataArgs): Promise<SignTypedDataResult>;
+export {};

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

@@ -0,0 +1,6 @@
+import { Chain } from '../../types';
+export declare type SwitchNetworkArgs = {
+    chainId: number;
+};
+export declare type SwitchNetworkResult = Chain;
+export declare function switchNetwork(args: SwitchNetworkArgs): Promise<SwitchNetworkResult>;

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

@@ -0,0 +1,3 @@
+import { GetAccountResult } from './getAccount';
+export declare type WatchAccountCallback = (data: GetAccountResult) => void;
+export declare function watchAccount(callback: WatchAccountCallback): () => void;

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

@@ -0,0 +1,3 @@
+import { FetchBalanceArgs, FetchBalanceResult } from './fetchBalance';
+export declare type WatchBalanceCallback = (balance: FetchBalanceResult) => void;
+export declare function watchBalance(args: FetchBalanceArgs, callback: WatchBalanceCallback): () => void;

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

@@ -0,0 +1,3 @@
+import { GetNetworkResult } from './getNetwork';
+export declare type WatchNetworkCallback = (data: GetNetworkResult) => void;
+export declare function watchNetwork(callback: WatchNetworkCallback): () => void;

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

@@ -0,0 +1,3 @@
+import { FetchSignerResult } from './fetchSigner';
+export declare type WatchSignerCallback = (data: FetchSignerResult) => void;
+export declare function watchSigner(callback: WatchSignerCallback): () => void;

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

@@ -0,0 +1,11 @@
+import type { Provider } from '@ethersproject/providers';
+import { Contract, ContractInterface, Signer } from 'ethers/lib/ethers';
+export declare type GetContractArgs = {
+    /** Contract address or ENS name */
+    addressOrName: string;
+    /** Contract interface or ABI */
+    contractInterface: ContractInterface;
+    /** Signer or provider to attach to contract */
+    signerOrProvider?: Signer | Provider;
+};
+export declare function getContract<T = Contract>({ addressOrName, contractInterface, signerOrProvider, }: GetContractArgs): T;

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

@@ -0,0 +1,5 @@
+export { getContract, type GetContractArgs } from './getContract';
+export { readContract, type ReadContractArgs, type ReadContractConfig, type ReadContractResult, } from './readContract';
+export { watchContractEvent } from './watchContractEvent';
+export { watchReadContract, type WatchReadContractArgs, type WatchReadContractConfig, type WatchReadContractResult, } from './watchReadContract';
+export { writeContract, type WriteContractArgs, type WriteContractConfig, type WriteContractResult, } from './writeContract';

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

@@ -0,0 +1,11 @@
+import { CallOverrides, Contract as EthersContract } from 'ethers/lib/ethers';
+import { Result } from 'ethers/lib/utils';
+import { GetContractArgs } from './getContract';
+export declare type ReadContractArgs = GetContractArgs;
+export declare type ReadContractConfig = {
+    /** Arguments to pass contract method */
+    args?: any | any[];
+    overrides?: CallOverrides;
+};
+export declare type ReadContractResult = Result;
+export declare function readContract<Contract extends EthersContract = EthersContract>(contractConfig: ReadContractArgs, functionName: string, { args, overrides }?: ReadContractConfig): Promise<Result>;

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

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

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

@@ -0,0 +1,7 @@
+import { ReadContractArgs, ReadContractConfig, ReadContractResult } from './readContract';
+export declare type WatchReadContractArgs = ReadContractArgs;
+export declare type WatchReadContractConfig = ReadContractConfig & {
+    listenToBlock?: boolean;
+};
+export declare type WatchReadContractResult = (result: ReadContractResult) => void;
+export declare function watchReadContract(contractConfig: WatchReadContractArgs, functionName: string, config: WatchReadContractConfig | undefined, callback: WatchReadContractResult): () => void;