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

package/dist/base-85d1eb89.cjs.dev.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;