@wagmi/core 0.2.1 → 0.2.4

package/dist/client-a06853e2.cjs.prod.js

@@ -0,0 +1,607 @@
+'use strict';
+
+var classPrivateMethodGet = require('./classPrivateMethodGet-d7330ed7.cjs.prod.js');
+var base = require('./base-59f3457e.cjs.prod.js');
+var ethers = require('ethers');
+var create = require('zustand/vanilla');
+var middleware = require('zustand/middleware');
+var utils = require('ethers/lib/utils');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { 'default': e }; }
+
+var create__default = /*#__PURE__*/_interopDefault(create);
+
+function getInjectedName(ethereum) {
+  var _ethereum$providers, _getName;
+
+  if (!ethereum) return 'Injected';
+
+  const getName = provider => {
+    if (provider.isBraveWallet) return 'Brave Wallet';
+    if (provider.isCoinbaseWallet) return 'Coinbase Wallet';
+    if (provider.isFrame) return 'Frame';
+    if (provider.isTally) return 'Tally';
+    if (provider.isTokenary) return 'Tokenary';
+    if (provider.isTrust) return 'Trust Wallet';
+    if (provider.isMetaMask) return 'MetaMask';
+  };
+
+  if ((_ethereum$providers = ethereum.providers) !== null && _ethereum$providers !== void 0 && _ethereum$providers.length) {
+    // Deduplicate names using Set
+    // Coinbase Wallet puts multiple providers in `ethereum.providers`
+    const nameSet = new Set();
+    let unknownCount = 1;
+
+    for (const provider of ethereum.providers) {
+      let name = getName(provider);
+
+      if (!name) {
+        name = "Unknown Wallet #".concat(unknownCount);
+        unknownCount += 1;
+      }
+
+      nameSet.add(name);
+    }
+
+    const names = [...nameSet];
+    return names.length ? names : names[0];
+  }
+
+  return (_getName = getName(ethereum)) !== null && _getName !== void 0 ? _getName : 'Injected';
+}
+
+const cache = new Set();
+function warn(message, id) {
+  if (!cache.has(id !== null && id !== void 0 ? id : message)) {
+    console.warn(message);
+    cache.add(message);
+  }
+}
+
+const shimKey = 'injected.shimDisconnect';
+
+var _provider = /*#__PURE__*/new WeakMap();
+
+class InjectedConnector extends base.Connector {
+  constructor(config) {
+    super({ ...config,
+      options: {
+        shimDisconnect: true,
+        ...(config === null || config === void 0 ? void 0 : config.options)
+      }
+    });
+
+    base._defineProperty(this, "id", void 0);
+
+    base._defineProperty(this, "name", void 0);
+
+    base._defineProperty(this, "ready", typeof window != 'undefined' && !!window.ethereum);
+
+    base._classPrivateFieldInitSpec(this, _provider, {
+      writable: true,
+      value: void 0
+    });
+
+    base._defineProperty(this, "onAccountsChanged", accounts => {
+      if (accounts.length === 0) this.emit('disconnect');else this.emit('change', {
+        account: utils.getAddress(accounts[0])
+      });
+    });
+
+    base._defineProperty(this, "onChainChanged", chainId => {
+      const id = base.normalizeChainId(chainId);
+      const unsupported = this.isChainUnsupported(id);
+      this.emit('change', {
+        chain: {
+          id,
+          unsupported
+        }
+      });
+    });
+
+    base._defineProperty(this, "onDisconnect", () => {
+      var _this$options, _getClient$storage;
+
+      this.emit('disconnect');
+      if ((_this$options = this.options) !== null && _this$options !== void 0 && _this$options.shimDisconnect) (_getClient$storage = getClient().storage) === null || _getClient$storage === void 0 ? void 0 : _getClient$storage.removeItem(shimKey);
+    });
+
+    let name = 'Injected';
+
+    if (typeof window !== 'undefined') {
+      var _config$options;
+
+      const overrideName = config === null || config === void 0 ? void 0 : (_config$options = config.options) === null || _config$options === void 0 ? void 0 : _config$options.name;
+      const detectedName = getInjectedName(window.ethereum);
+      if (overrideName) name = typeof overrideName === 'function' ? overrideName(detectedName) : overrideName;else name = typeof detectedName === 'string' ? detectedName : detectedName[0];
+    }
+
+    this.id = 'injected';
+    this.name = name;
+  }
+
+  async connect() {
+    try {
+      var _this$options2, _getClient$storage2;
+
+      const provider = await this.getProvider();
+      if (!provider) throw new base.ConnectorNotFoundError();
+
+      if (provider.on) {
+        provider.on('accountsChanged', this.onAccountsChanged);
+        provider.on('chainChanged', this.onChainChanged);
+        provider.on('disconnect', this.onDisconnect);
+      }
+
+      this.emit('message', {
+        type: 'connecting'
+      });
+      const account = await this.getAccount();
+      const id = await this.getChainId();
+      const unsupported = this.isChainUnsupported(id);
+      if ((_this$options2 = this.options) !== null && _this$options2 !== void 0 && _this$options2.shimDisconnect) (_getClient$storage2 = getClient().storage) === null || _getClient$storage2 === void 0 ? void 0 : _getClient$storage2.setItem(shimKey, true);
+      return {
+        account,
+        chain: {
+          id,
+          unsupported
+        },
+        provider
+      };
+    } catch (error) {
+      if (error.code === 4001) throw new base.UserRejectedRequestError();
+      throw error;
+    }
+  }
+
+  async disconnect() {
+    var _this$options3, _getClient$storage3;
+
+    const provider = await this.getProvider();
+    if (!(provider !== null && provider !== void 0 && provider.removeListener)) return;
+    provider.removeListener('accountsChanged', this.onAccountsChanged);
+    provider.removeListener('chainChanged', this.onChainChanged);
+    provider.removeListener('disconnect', this.onDisconnect);
+    if ((_this$options3 = this.options) !== null && _this$options3 !== void 0 && _this$options3.shimDisconnect) (_getClient$storage3 = getClient().storage) === null || _getClient$storage3 === void 0 ? void 0 : _getClient$storage3.removeItem(shimKey);
+  }
+
+  async getAccount() {
+    const provider = await this.getProvider();
+    if (!provider) throw new base.ConnectorNotFoundError();
+    const accounts = await provider.request({
+      method: 'eth_requestAccounts'
+    }); // return checksum address
+
+    return utils.getAddress(accounts[0]);
+  }
+
+  async getChainId() {
+    const provider = await this.getProvider();
+    if (!provider) throw new base.ConnectorNotFoundError();
+    return await provider.request({
+      method: 'eth_chainId'
+    }).then(base.normalizeChainId);
+  }
+
+  async getProvider() {
+    if (typeof window !== 'undefined' && !!window.ethereum) base._classPrivateFieldSet(this, _provider, window.ethereum);
+    return base._classPrivateFieldGet(this, _provider);
+  }
+
+  async getSigner() {
+    const [provider, account] = await Promise.all([this.getProvider(), this.getAccount()]);
+    return new ethers.providers.Web3Provider(provider).getSigner(account);
+  }
+
+  async isAuthorized() {
+    try {
+      var _this$options4, _getClient$storage4;
+
+      if ((_this$options4 = this.options) !== null && _this$options4 !== void 0 && _this$options4.shimDisconnect && !((_getClient$storage4 = getClient().storage) !== null && _getClient$storage4 !== void 0 && _getClient$storage4.getItem(shimKey))) return false;
+      const provider = await this.getProvider();
+      if (!provider) throw new base.ConnectorNotFoundError();
+      const accounts = await provider.request({
+        method: 'eth_accounts'
+      });
+      const account = accounts[0];
+      return !!account;
+    } catch {
+      return false;
+    }
+  }
+
+  async switchChain(chainId) {
+    const provider = await this.getProvider();
+    if (!provider) throw new base.ConnectorNotFoundError();
+    const id = utils.hexValue(chainId);
+
+    try {
+      var _chains$find;
+
+      await provider.request({
+        method: 'wallet_switchEthereumChain',
+        params: [{
+          chainId: id
+        }]
+      });
+      const chains = [...this.chains, ...base.allChains];
+      return (_chains$find = chains.find(x => x.id === chainId)) !== null && _chains$find !== void 0 ? _chains$find : {
+        id: chainId,
+        name: "Chain ".concat(id),
+        rpcUrls: {
+          default: ''
+        }
+      };
+    } catch (error) {
+      // Indicates chain is not added to provider
+      if (error.code === 4902) {
+        try {
+          const chain = this.chains.find(x => x.id === chainId);
+          if (!chain) throw new base.ChainNotConfiguredError();
+          await provider.request({
+            method: 'wallet_addEthereumChain',
+            params: [{
+              chainId: id,
+              chainName: chain.name,
+              nativeCurrency: chain.nativeCurrency,
+              rpcUrls: [chain.rpcUrls.default],
+              blockExplorerUrls: this.getBlockExplorerUrls(chain)
+            }]
+          });
+          return chain;
+        } catch (addError) {
+          throw new base.AddChainError();
+        }
+      } else if (error.code === 4001) throw new base.UserRejectedRequestError();else throw new base.SwitchChainError();
+    }
+  }
+
+  async watchAsset(_ref) {
+    let {
+      address,
+      decimals = 18,
+      image,
+      symbol
+    } = _ref;
+    const provider = await this.getProvider();
+    if (!provider) throw new base.ConnectorNotFoundError();
+    return await provider.request({
+      method: 'wallet_watchAsset',
+      params: {
+        type: 'ERC20',
+        options: {
+          address,
+          decimals,
+          image,
+          symbol
+        }
+      }
+    });
+  }
+
+}
+
+const noopStorage = {
+  getItem: _key => '',
+  setItem: (_key, _value) => null,
+  removeItem: _key => null
+};
+function createStorage(_ref) {
+  let {
+    storage,
+    key: prefix = 'wagmi'
+  } = _ref;
+  return { ...storage,
+    getItem: function (key) {
+      let defaultState = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null;
+      const value = storage.getItem("".concat(prefix, ".").concat(key));
+
+      try {
+        return value ? JSON.parse(value) : defaultState;
+      } catch (error) {
+        console.warn(error);
+        return defaultState;
+      }
+    },
+    setItem: (key, value) => {
+      if (value === null) {
+        storage.removeItem("".concat(prefix, ".").concat(key));
+      } else {
+        try {
+          storage.setItem("".concat(prefix, ".").concat(key), JSON.stringify(value));
+        } catch (err) {
+          console.error(err);
+        }
+      }
+    },
+    removeItem: key => storage.removeItem("".concat(prefix, ".").concat(key))
+  };
+}
+
+const storeKey = 'store';
+
+var _lastUsedConnector = /*#__PURE__*/new WeakMap();
+
+var _addEffects = /*#__PURE__*/new WeakSet();
+
+class Client {
+  constructor() {
+    var _config$autoConnect, _config$connectors, _config$provider, _config$storage;
+
+    let config = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+
+    classPrivateMethodGet._classPrivateMethodInitSpec(this, _addEffects);
+
+    base._defineProperty(this, "config", void 0);
+
+    base._defineProperty(this, "storage", void 0);
+
+    base._defineProperty(this, "store", void 0);
+
+    base._classPrivateFieldInitSpec(this, _lastUsedConnector, {
+      writable: true,
+      value: void 0
+    });
+
+    // Set default values for config
+    const autoConnect = (_config$autoConnect = config.autoConnect) !== null && _config$autoConnect !== void 0 ? _config$autoConnect : false;
+
+    const _connectors = (_config$connectors = config.connectors) !== null && _config$connectors !== void 0 ? _config$connectors : [new InjectedConnector()];
+
+    const _provider = (_config$provider = config.provider) !== null && _config$provider !== void 0 ? _config$provider : config => {
+      try {
+        return ethers.getDefaultProvider(config.chainId);
+      } catch {
+        return ethers.getDefaultProvider();
+      }
+    };
+
+    const storage = (_config$storage = config.storage) !== null && _config$storage !== void 0 ? _config$storage : createStorage({
+      storage: typeof window !== 'undefined' ? window.localStorage : noopStorage
+    });
+    const _webSocketProvider = config.webSocketProvider; // Check status for autoConnect flag
+
+    let status = 'disconnected';
+
+    let _chainId;
+
+    if (autoConnect) {
+      try {
+        var _JSON$parse, _JSON$parse$state, _data$chain;
+
+        const rawState = storage.getItem(storeKey, '');
+        const data = (_JSON$parse = JSON.parse(rawState || '{}')) === null || _JSON$parse === void 0 ? void 0 : (_JSON$parse$state = _JSON$parse.state) === null || _JSON$parse$state === void 0 ? void 0 : _JSON$parse$state.data; // If account exists in localStorage, set status to reconnecting
+
+        status = data !== null && data !== void 0 && data.account ? 'reconnecting' : 'connecting';
+        _chainId = data === null || data === void 0 ? void 0 : (_data$chain = data.chain) === null || _data$chain === void 0 ? void 0 : _data$chain.id; // eslint-disable-next-line no-empty
+      } catch (_error) {}
+    } // Evaluate initial store values
+
+
+    const connectors_ = typeof _connectors === 'function' ? _connectors({
+      chainId: _chainId
+    }) : _connectors;
+    const provider_ = typeof _provider === 'function' ? _provider({
+      chainId: _chainId
+    }) : _provider;
+    const webSocketProvider_ = typeof _webSocketProvider === 'function' ? _webSocketProvider({
+      chainId: _chainId
+    }) : _webSocketProvider; // Create store
+
+    this.store = create__default["default"](middleware.subscribeWithSelector(middleware.persist(() => ({
+      connectors: connectors_,
+      provider: provider_,
+      status,
+      webSocketProvider: webSocketProvider_
+    }), {
+      name: storeKey,
+      getStorage: () => storage,
+      partialize: state => {
+        var _state$data, _state$data2;
+
+        return { ...(autoConnect && {
+            data: {
+              account: state === null || state === void 0 ? void 0 : (_state$data = state.data) === null || _state$data === void 0 ? void 0 : _state$data.account,
+              chain: state === null || state === void 0 ? void 0 : (_state$data2 = state.data) === null || _state$data2 === void 0 ? void 0 : _state$data2.chain
+            }
+          }),
+          chains: state === null || state === void 0 ? void 0 : state.chains
+        };
+      },
+      version: 1
+    })));
+    this.config = {
+      autoConnect,
+      connectors: _connectors,
+      provider: _provider,
+      storage,
+      webSocketProvider: _webSocketProvider
+    };
+    this.storage = storage;
+
+    base._classPrivateFieldSet(this, _lastUsedConnector, storage === null || storage === void 0 ? void 0 : storage.getItem('wallet'));
+
+    classPrivateMethodGet._classPrivateMethodGet(this, _addEffects, _addEffects2).call(this);
+  }
+
+  get chains() {
+    return this.store.getState().chains;
+  }
+
+  get connectors() {
+    return this.store.getState().connectors;
+  }
+
+  get connector() {
+    return this.store.getState().connector;
+  }
+
+  get data() {
+    return this.store.getState().data;
+  }
+
+  get error() {
+    return this.store.getState().error;
+  }
+
+  get provider() {
+    return this.store.getState().provider;
+  }
+
+  get status() {
+    return this.store.getState().status;
+  }
+
+  get subscribe() {
+    return this.store.subscribe;
+  }
+
+  get webSocketProvider() {
+    return this.store.getState().webSocketProvider;
+  }
+
+  setState(updater) {
+    const newState = typeof updater === 'function' ? updater(this.store.getState()) : updater;
+    this.store.setState(newState, true);
+  }
+
+  clearState() {
+    this.setState(x => ({ ...x,
+      connector: undefined,
+      data: undefined,
+      error: undefined,
+      status: 'disconnected'
+    }));
+  }
+
+  async destroy() {
+    var _this$connector$disco, _this$connector;
+
+    if (this.connector) await ((_this$connector$disco = (_this$connector = this.connector).disconnect) === null || _this$connector$disco === void 0 ? void 0 : _this$connector$disco.call(_this$connector));
+    this.clearState();
+    this.store.destroy();
+  }
+
+  async autoConnect() {
+    if (!this.connectors.length) return; // Try last used connector first
+
+    const sorted = base._classPrivateFieldGet(this, _lastUsedConnector) ? [...this.connectors].sort(x => x.id === base._classPrivateFieldGet(this, _lastUsedConnector) ? -1 : 1) : this.connectors;
+    let connected = false;
+
+    for (const connector of sorted) {
+      if (!connector.ready || !connector.isAuthorized) continue;
+      const isAuthorized = await connector.isAuthorized();
+      if (!isAuthorized) continue;
+      const data = await connector.connect();
+      this.setState(x => ({ ...x,
+        connector,
+        chains: connector === null || connector === void 0 ? void 0 : connector.chains,
+        data,
+        status: 'connected'
+      }));
+      connected = true;
+      break;
+    } // If connecting didn't succeed, set to disconnected
+
+
+    if (!connected) this.setState(x => ({ ...x,
+      status: 'disconnected'
+    }));
+    return this.data;
+  }
+
+  setLastUsedConnector() {
+    var _this$storage;
+
+    let lastUsedConnector = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : null;
+    (_this$storage = this.storage) === null || _this$storage === void 0 ? void 0 : _this$storage.setItem('wallet', lastUsedConnector);
+  }
+
+}
+
+function _addEffects2() {
+  const onChange = data => {
+    this.setState(x => ({ ...x,
+      data: { ...x.data,
+        ...data
+      }
+    }));
+  };
+
+  const onDisconnect = () => {
+    this.clearState();
+  };
+
+  const onError = error => {
+    this.setState(x => ({ ...x,
+      error
+    }));
+  };
+
+  this.store.subscribe(_ref => {
+    let {
+      connector
+    } = _ref;
+    return connector;
+  }, (connector, prevConnector) => {
+    var _prevConnector$off, _prevConnector$off2, _prevConnector$off3, _connector$on, _connector$on2, _connector$on3;
+
+    prevConnector === null || prevConnector === void 0 ? void 0 : (_prevConnector$off = prevConnector.off) === null || _prevConnector$off === void 0 ? void 0 : _prevConnector$off.call(prevConnector, 'change', onChange);
+    prevConnector === null || prevConnector === void 0 ? void 0 : (_prevConnector$off2 = prevConnector.off) === null || _prevConnector$off2 === void 0 ? void 0 : _prevConnector$off2.call(prevConnector, 'disconnect', onDisconnect);
+    prevConnector === null || prevConnector === void 0 ? void 0 : (_prevConnector$off3 = prevConnector.off) === null || _prevConnector$off3 === void 0 ? void 0 : _prevConnector$off3.call(prevConnector, 'error', onError);
+    if (!connector) return;
+    (_connector$on = connector.on) === null || _connector$on === void 0 ? void 0 : _connector$on.call(connector, 'change', onChange);
+    (_connector$on2 = connector.on) === null || _connector$on2 === void 0 ? void 0 : _connector$on2.call(connector, 'disconnect', onDisconnect);
+    (_connector$on3 = connector.on) === null || _connector$on3 === void 0 ? void 0 : _connector$on3.call(connector, 'error', onError);
+  });
+  const {
+    connectors,
+    provider,
+    webSocketProvider
+  } = this.config;
+  const subscribeConnectors = typeof connectors === 'function';
+  const subscribeProvider = typeof provider === 'function';
+  const subscribeWebSocketProvider = typeof webSocketProvider === 'function';
+  if (subscribeConnectors || subscribeProvider || subscribeWebSocketProvider) this.store.subscribe(_ref2 => {
+    var _data$chain2;
+
+    let {
+      data
+    } = _ref2;
+    return data === null || data === void 0 ? void 0 : (_data$chain2 = data.chain) === null || _data$chain2 === void 0 ? void 0 : _data$chain2.id;
+  }, chainId => {
+    this.setState(x => ({ ...x,
+      connectors: subscribeConnectors ? connectors({
+        chainId
+      }) : x.connectors,
+      provider: subscribeProvider ? provider({
+        chainId
+      }) : x.provider,
+      webSocketProvider: subscribeWebSocketProvider ? webSocketProvider({
+        chainId
+      }) : x.webSocketProvider
+    }));
+  });
+}
+
+exports.client = void 0;
+function createClient(config) {
+  const client_ = new Client(config);
+  exports.client = client_;
+  return client_;
+}
+function getClient() {
+  if (!exports.client) {
+    warn('No client defined. Falling back to default client.');
+    return new Client();
+  }
+
+  return exports.client;
+}
+
+exports.Client = Client;
+exports.InjectedConnector = InjectedConnector;
+exports.createClient = createClient;
+exports.createStorage = createStorage;
+exports.getClient = getClient;
+exports.noopStorage = noopStorage;

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

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

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

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

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

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

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

@@ -1,11 +1,10 @@
-import type { Provider } from '@ethersproject/providers';
-import { Contract, ContractInterface, Signer } from 'ethers/lib/ethers';
+import { Contract, ContractInterface, Signer, providers } from '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 | null;
+    signerOrProvider?: Signer | providers.Provider | null;
 };
 export declare function getContract<T = Contract>({ addressOrName, contractInterface, signerOrProvider, }: GetContractArgs): T;

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

@@ -1,7 +1,7 @@
 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 ReadContractArgs = Pick<GetContractArgs, 'addressOrName' | 'contractInterface'>;
 export declare type ReadContractConfig = {
     /** Arguments to pass contract method */
     args?: any | any[];

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

@@ -1,5 +1,4 @@
-import type { TransactionResponse } from '@ethersproject/providers';
-import { CallOverrides, Contract as EthersContract } from 'ethers/lib/ethers';
+import { CallOverrides, Contract as EthersContract, providers } from 'ethers';
 import { GetContractArgs } from './getContract';
 export declare type WriteContractArgs = GetContractArgs;
 export declare type WriteContractConfig = {
@@ -7,5 +6,5 @@ export declare type WriteContractConfig = {
     args?: any | any[];
     overrides?: CallOverrides;
 };
-export declare type WriteContractResult = TransactionResponse;
+export declare type WriteContractResult = providers.TransactionResponse;
 export declare function writeContract<Contract extends EthersContract = EthersContract>(contractConfig: WriteContractArgs, functionName: string, { args, overrides }?: WriteContractConfig): Promise<WriteContractResult>;