@wagmi/core 0.3.8 → 0.4.0-test.2

package/dist/base-c546f171.esm.js

@@ -0,0 +1,603 @@
+import { d as defaultChains } from './chains-fa406563.esm.js';
+
+function _checkPrivateRedeclaration(obj, privateCollection) {
+  if (privateCollection.has(obj)) {
+    throw new TypeError("Cannot initialize the same private elements twice on an object");
+  }
+}
+
+function _classPrivateMethodInitSpec(obj, privateSet) {
+  _checkPrivateRedeclaration(obj, privateSet);
+  privateSet.add(obj);
+}
+
+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 _classPrivateMethodGet(receiver, privateSet, fn) {
+  if (!privateSet.has(receiver)) {
+    throw new TypeError("attempted to get private field on non-instance");
+  }
+
+  return fn;
+}
+
+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;
+}
+
+function normalizeChainId(chainId) {
+  if (typeof chainId === 'string') return Number.parseInt(chainId, chainId.trim().substring(0, 2) === '0x' ? 16 : 10);
+  return chainId;
+}
+
+/**
+ * Error subclass implementing JSON RPC 2.0 errors and Ethereum RPC errors per EIP-1474.
+ * @see https://eips.ethereum.org/EIPS/eip-1474
+ */
+class RpcError extends Error {
+  constructor(
+  /** Number error code */
+  code,
+  /** Human-readable string */
+  message,
+  /** Low-level error */
+  internal,
+  /** Other useful information about error */
+  data) {
+    if (!Number.isInteger(code)) throw new Error('"code" must be an integer.');
+    if (!message || typeof message !== 'string') throw new Error('"message" must be a nonempty string.');
+    super(message);
+
+    _defineProperty(this, "code", void 0);
+
+    _defineProperty(this, "data", void 0);
+
+    _defineProperty(this, "internal", void 0);
+
+    this.code = code;
+    this.data = data;
+    this.internal = internal;
+  }
+
+}
+/**
+ * Error subclass implementing Ethereum Provider errors per EIP-1193.
+ * @see https://eips.ethereum.org/EIPS/eip-1193
+ */
+
+class ProviderRpcError extends RpcError {
+  /**
+   * Create an Ethereum Provider JSON-RPC error.
+   * `code` must be an integer in the 1000 <= 4999 range.
+   */
+  constructor(
+  /**
+   * Number error code
+   * @see https://eips.ethereum.org/EIPS/eip-1193#error-standards
+   */
+  code,
+  /** Human-readable string */
+  message,
+  /** Low-level error */
+  internal,
+  /** Other useful information about error */
+  data) {
+    if (!(Number.isInteger(code) && code >= 1000 && code <= 4999)) throw new Error('"code" must be an integer such that: 1000 <= code <= 4999');
+    super(code, message, internal, data);
+  }
+
+}
+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 ProviderRpcError {
+  constructor(error) {
+    super(4902, 'Error switching chain', error);
+
+    _defineProperty(this, "name", 'SwitchChainError');
+  }
+
+}
+class SwitchChainNotSupportedError extends Error {
+  constructor() {
+    super(...arguments);
+
+    _defineProperty(this, "name", 'SwitchChainNotSupportedError');
+
+    _defineProperty(this, "message", 'Switch chain not supported by connector');
+  }
+
+}
+class UserRejectedRequestError extends ProviderRpcError {
+  constructor(error) {
+    super(4001, 'User rejected request', error);
+
+    _defineProperty(this, "name", 'UserRejectedRequestError');
+  }
+
+}
+class ResourceUnavailableError extends RpcError {
+  constructor(error) {
+    super(-32002, 'Resource unavailable', error);
+
+    _defineProperty(this, "name", 'ResourceUnavailable');
+  }
+
+}
+
+const has = Object.prototype.hasOwnProperty;
+let prefix = '~';
+/**
+ * Constructor to create a storage for our `EE` objects.
+ * An `Events` instance is a plain object whose properties are event names.
+ *
+ * @constructor
+ * @private
+ */
+// eslint-disable-next-line @typescript-eslint/no-empty-function
+
+function Events() {} //
+// We try to not inherit from `Object.prototype`. In some engines creating an
+// instance in this way is faster than calling `Object.create(null)` directly.
+// If `Object.create(null)` is not supported we prefix the event names with a
+// character to make sure that the built-in object properties are not
+// overridden or used as an attack vector.
+//
+
+
+if (Object.create) {
+  Events.prototype = Object.create(null); //
+  // This hack is needed because the `__proto__` property is still inherited in
+  // some old browsers like Android 4, iPhone 5.1, Opera 11 and Safari 5.
+  //
+
+  if (!new Events().__proto__) prefix = false;
+}
+/**
+ * Representation of a single event listener.
+ *
+ * @param {Function} fn The listener function.
+ * @param {*} context The context to invoke the listener with.
+ * @param {Boolean} [once=false] Specify if the listener is a one-time listener.
+ * @constructor
+ * @private
+ */
+
+
+function EE(fn, context, once) {
+  this.fn = fn;
+  this.context = context;
+  this.once = once || false;
+}
+/**
+ * Add a listener for a given event.
+ *
+ * @param {EventEmitter} emitter Reference to the `EventEmitter` instance.
+ * @param {(String|Symbol)} event The event name.
+ * @param {Function} fn The listener function.
+ * @param {*} context The context to invoke the listener with.
+ * @param {Boolean} once Specify if the listener is a one-time listener.
+ * @returns {EventEmitter}
+ * @private
+ */
+
+
+function addListener(emitter, event, fn, context, once) {
+  if (typeof fn !== 'function') {
+    throw new TypeError('The listener must be a function');
+  }
+
+  var listener = new EE(fn, context || emitter, once),
+      evt = prefix ? prefix + event : event;
+  if (!emitter._events[evt]) emitter._events[evt] = listener, emitter._eventsCount++;else if (!emitter._events[evt].fn) emitter._events[evt].push(listener);else emitter._events[evt] = [emitter._events[evt], listener];
+  return emitter;
+}
+/**
+ * Clear event by name.
+ *
+ * @param {EventEmitter} emitter Reference to the `EventEmitter` instance.
+ * @param {(String|Symbol)} evt The Event name.
+ * @private
+ */
+
+
+function clearEvent(emitter, evt) {
+  if (--emitter._eventsCount === 0) emitter._events = new Events();else delete emitter._events[evt];
+}
+/**
+ * Minimal `EventEmitter` interface that is molded against the Node.js
+ * `EventEmitter` interface.
+ *
+ * @constructor
+ * @public
+ */
+
+
+function EventEmitter() {
+  this._events = new Events();
+  this._eventsCount = 0;
+}
+/**
+ * Return an array listing the events for which the emitter has registered
+ * listeners.
+ *
+ * @returns {Array}
+ * @public
+ */
+
+
+EventEmitter.prototype.eventNames = function eventNames() {
+  var names = [],
+      events,
+      name;
+  if (this._eventsCount === 0) return names;
+
+  for (name in events = this._events) {
+    if (has.call(events, name)) names.push(prefix ? name.slice(1) : name);
+  }
+
+  if (Object.getOwnPropertySymbols) {
+    return names.concat(Object.getOwnPropertySymbols(events));
+  }
+
+  return names;
+};
+/**
+ * Return the listeners registered for a given event.
+ *
+ * @param {(String|Symbol)} event The event name.
+ * @returns {Array} The registered listeners.
+ * @public
+ */
+
+
+EventEmitter.prototype.listeners = function listeners(event) {
+  var evt = prefix ? prefix + event : event,
+      handlers = this._events[evt];
+  if (!handlers) return [];
+  if (handlers.fn) return [handlers.fn];
+
+  for (var i = 0, l = handlers.length, ee = new Array(l); i < l; i++) {
+    ee[i] = handlers[i].fn;
+  }
+
+  return ee;
+};
+/**
+ * Return the number of listeners listening to a given event.
+ *
+ * @param {(String|Symbol)} event The event name.
+ * @returns {Number} The number of listeners.
+ * @public
+ */
+
+
+EventEmitter.prototype.listenerCount = function listenerCount(event) {
+  var evt = prefix ? prefix + event : event,
+      listeners = this._events[evt];
+  if (!listeners) return 0;
+  if (listeners.fn) return 1;
+  return listeners.length;
+};
+/**
+ * Calls each of the listeners registered for a given event.
+ *
+ * @param {(String|Symbol)} event The event name.
+ * @returns {Boolean} `true` if the event had listeners, else `false`.
+ * @public
+ */
+
+
+EventEmitter.prototype.emit = function emit(event, a1, a2, a3, a4, a5) {
+  var evt = prefix ? prefix + event : event;
+  if (!this._events[evt]) return false;
+  var listeners = this._events[evt],
+      len = arguments.length,
+      args,
+      i;
+
+  if (listeners.fn) {
+    if (listeners.once) this.removeListener(event, listeners.fn, undefined, true);
+
+    switch (len) {
+      case 1:
+        return listeners.fn.call(listeners.context), true;
+
+      case 2:
+        return listeners.fn.call(listeners.context, a1), true;
+
+      case 3:
+        return listeners.fn.call(listeners.context, a1, a2), true;
+
+      case 4:
+        return listeners.fn.call(listeners.context, a1, a2, a3), true;
+
+      case 5:
+        return listeners.fn.call(listeners.context, a1, a2, a3, a4), true;
+
+      case 6:
+        return listeners.fn.call(listeners.context, a1, a2, a3, a4, a5), true;
+    }
+
+    for (i = 1, args = new Array(len - 1); i < len; i++) {
+      args[i - 1] = arguments[i];
+    }
+
+    listeners.fn.apply(listeners.context, args);
+  } else {
+    var length = listeners.length,
+        j;
+
+    for (i = 0; i < length; i++) {
+      if (listeners[i].once) this.removeListener(event, listeners[i].fn, undefined, true);
+
+      switch (len) {
+        case 1:
+          listeners[i].fn.call(listeners[i].context);
+          break;
+
+        case 2:
+          listeners[i].fn.call(listeners[i].context, a1);
+          break;
+
+        case 3:
+          listeners[i].fn.call(listeners[i].context, a1, a2);
+          break;
+
+        case 4:
+          listeners[i].fn.call(listeners[i].context, a1, a2, a3);
+          break;
+
+        default:
+          if (!args) for (j = 1, args = new Array(len - 1); j < len; j++) {
+            args[j - 1] = arguments[j];
+          }
+          listeners[i].fn.apply(listeners[i].context, args);
+      }
+    }
+  }
+
+  return true;
+};
+/**
+ * Add a listener for a given event.
+ *
+ * @param {(String|Symbol)} event The event name.
+ * @param {Function} fn The listener function.
+ * @param {*} [context=this] The context to invoke the listener with.
+ * @returns {EventEmitter} `this`.
+ * @public
+ */
+
+
+EventEmitter.prototype.on = function on(event, fn, context) {
+  return addListener(this, event, fn, context, false);
+};
+/**
+ * Add a one-time listener for a given event.
+ *
+ * @param {(String|Symbol)} event The event name.
+ * @param {Function} fn The listener function.
+ * @param {*} [context=this] The context to invoke the listener with.
+ * @returns {EventEmitter} `this`.
+ * @public
+ */
+
+
+EventEmitter.prototype.once = function once(event, fn, context) {
+  return addListener(this, event, fn, context, true);
+};
+/**
+ * Remove the listeners of a given event.
+ *
+ * @param {(String|Symbol)} event The event name.
+ * @param {Function} fn Only remove the listeners that match this function.
+ * @param {*} context Only remove the listeners that have this context.
+ * @param {Boolean} once Only remove one-time listeners.
+ * @returns {EventEmitter} `this`.
+ * @public
+ */
+
+
+EventEmitter.prototype.removeListener = function removeListener(event, fn, context, once) {
+  var evt = prefix ? prefix + event : event;
+  if (!this._events[evt]) return this;
+
+  if (!fn) {
+    clearEvent(this, evt);
+    return this;
+  }
+
+  var listeners = this._events[evt];
+
+  if (listeners.fn) {
+    if (listeners.fn === fn && (!once || listeners.once) && (!context || listeners.context === context)) {
+      clearEvent(this, evt);
+    }
+  } else {
+    for (var i = 0, events = [], length = listeners.length; i < length; i++) {
+      if (listeners[i].fn !== fn || once && !listeners[i].once || context && listeners[i].context !== context) {
+        events.push(listeners[i]);
+      }
+    } //
+    // Reset the array, or remove it completely if we have no more listeners.
+    //
+
+
+    if (events.length) this._events[evt] = events.length === 1 ? events[0] : events;else clearEvent(this, evt);
+  }
+
+  return this;
+};
+/**
+ * Remove all listeners, or those of the specified event.
+ *
+ * @param {(String|Symbol)} [event] The event name.
+ * @returns {EventEmitter} `this`.
+ * @public
+ */
+
+
+EventEmitter.prototype.removeAllListeners = function removeAllListeners(event) {
+  var evt;
+
+  if (event) {
+    evt = prefix ? prefix + event : event;
+    if (this._events[evt]) clearEvent(this, evt);
+  } else {
+    this._events = new Events();
+    this._eventsCount = 0;
+  }
+
+  return this;
+}; //
+// Alias methods names because people roll like that.
+//
+
+
+EventEmitter.prototype.off = EventEmitter.prototype.removeListener;
+EventEmitter.prototype.addListener = EventEmitter.prototype.on; //
+// Expose the prefix.
+//
+
+EventEmitter.prefixed = prefix;
+
+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 {
+      default: blockExplorer,
+      ...blockExplorers
+    } = (_chain$blockExplorers = chain.blockExplorers) !== null && _chain$blockExplorers !== void 0 ? _chain$blockExplorers : {};
+    if (blockExplorer) return [blockExplorer.url, ...Object.values(blockExplorers).map(x => x.url)];
+    return [];
+  }
+
+  isChainUnsupported(chainId) {
+    return !this.chains.some(x => x.id === chainId);
+  }
+
+}
+
+export { AddChainError as A, ConnectorAlreadyConnectedError as C, EventEmitter as E, ProviderRpcError as P, ResourceUnavailableError as R, SwitchChainNotSupportedError as S, UserRejectedRequestError as U, _classPrivateMethodInitSpec as _, ConnectorNotFoundError as a, Connector as b, ChainNotConfiguredError as c, RpcError as d, SwitchChainError as e, _defineProperty as f, _classPrivateFieldInitSpec as g, _classPrivateFieldGet as h, _classPrivateFieldSet as i, _classPrivateMethodGet as j, normalizeChainId as n };

package/dist/{chains-b4a51a84.cjs.dev.js → chains-7e369752.cjs.dev.js}

@@ -92,7 +92,7 @@ const ropsten = {
   ensAddress: '0x00000000000C2E074eC69A0dFb2997BA6C7d2e1e',
   nativeCurrency: {
     name: 'Ropsten Ether',
-    symbol: 'ropETH',
+    symbol: 'ROP',
     decimals: 18
   },
   rpcUrls: {
@@ -113,7 +113,7 @@ const rinkeby = {
   ensAddress: '0x00000000000C2E074eC69A0dFb2997BA6C7d2e1e',
   nativeCurrency: {
     name: 'Rinkeby Ether',
-    symbol: 'rETH',
+    symbol: 'RIN',
     decimals: 18
   },
   rpcUrls: {
@@ -134,7 +134,7 @@ const goerli = {
   ensAddress: '0x00000000000C2E074eC69A0dFb2997BA6C7d2e1e',
   nativeCurrency: {
     name: 'Goerli Ether',
-    symbol: 'gETH',
+    symbol: 'GOR',
     decimals: 18
   },
   rpcUrls: {
@@ -154,7 +154,7 @@ const kovan = {
   network: 'kovan',
   nativeCurrency: {
     name: 'Kovan Ether',
-    symbol: 'kETH',
+    symbol: 'KOV',
     decimals: 18
   },
   rpcUrls: {
@@ -248,11 +248,11 @@ const polygonMumbai = {
 };
 const arbitrum = {
   id: chainId.arbitrum,
-  name: 'Arbitrum',
+  name: 'Arbitrum One',
   network: 'arbitrum',
   nativeCurrency: {
     name: 'Ether',
-    symbol: 'AETH',
+    symbol: 'ETH',
     decimals: 18
   },
   rpcUrls: {

package/dist/{chains-7204b2dd.cjs.prod.js → chains-d045862c.cjs.prod.js}

@@ -92,7 +92,7 @@ const ropsten = {
   ensAddress: '0x00000000000C2E074eC69A0dFb2997BA6C7d2e1e',
   nativeCurrency: {
     name: 'Ropsten Ether',
-    symbol: 'ropETH',
+    symbol: 'ROP',
     decimals: 18
   },
   rpcUrls: {
@@ -113,7 +113,7 @@ const rinkeby = {
   ensAddress: '0x00000000000C2E074eC69A0dFb2997BA6C7d2e1e',
   nativeCurrency: {
     name: 'Rinkeby Ether',
-    symbol: 'rETH',
+    symbol: 'RIN',
     decimals: 18
   },
   rpcUrls: {
@@ -134,7 +134,7 @@ const goerli = {
   ensAddress: '0x00000000000C2E074eC69A0dFb2997BA6C7d2e1e',
   nativeCurrency: {
     name: 'Goerli Ether',
-    symbol: 'gETH',
+    symbol: 'GOR',
     decimals: 18
   },
   rpcUrls: {
@@ -154,7 +154,7 @@ const kovan = {
   network: 'kovan',
   nativeCurrency: {
     name: 'Kovan Ether',
-    symbol: 'kETH',
+    symbol: 'KOV',
     decimals: 18
   },
   rpcUrls: {
@@ -248,11 +248,11 @@ const polygonMumbai = {
 };
 const arbitrum = {
   id: chainId.arbitrum,
-  name: 'Arbitrum',
+  name: 'Arbitrum One',
   network: 'arbitrum',
   nativeCurrency: {
     name: 'Ether',
-    symbol: 'AETH',
+    symbol: 'ETH',
     decimals: 18
   },
   rpcUrls: {