text: "use strict";
  var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
      function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
      return new (P || (P = Promise))(function (resolve, reject) {
          function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
          function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
          function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
          step((generator = generator.apply(thisArg, _arguments || [])).next());
      });
  };
  import { ForkEvent, Provider } from "@ethersproject/abstract-provider";
  import { Base58 } from "@ethersproject/basex";
  import { BigNumber } from "@ethersproject/bignumber";
  import { arrayify, concat, hexConcat, hexDataLength, hexDataSlice, hexlify, hexValue, hexZeroPad, isHexString } from "@ethersproject/bytes";
  import { HashZero } from "@ethersproject/constants";
  import { namehash } from "@ethersproject/hash";
  import { getNetwork } from "@ethersproject/networks";
  import { defineReadOnly, getStatic, resolveProperties } from "@ethersproject/properties";
  import { sha256 } from "@ethersproject/sha2";
  import { toUtf8Bytes, toUtf8String } from "@ethersproject/strings";
  import { poll } from "@ethersproject/web";
  import bech32 from "bech32";
  import { Logger } from "@ethersproject/logger";
  import { version } from "./_version";
  const logger = new Logger(version);
  import { Formatter } from "./formatter";
  //////////////////////////////
  // Event Serializeing
  function checkTopic(topic) {
      if (topic == null) {
          return "null";
      }
      if (hexDataLength(topic) !== 32) {
          logger.throwArgumentError("invalid topic", "topic", topic);
      }
      return topic.toLowerCase();
  }
  function serializeTopics(topics) {
      // Remove trailing null AND-topics; they are redundant
      topics = topics.slice();
      while (topics.length > 0 && topics[topics.length - 1] == null) {
          topics.pop();
      }
      return topics.map((topic) => {
          if (Array.isArray(topic)) {
              // Only track unique OR-topics
              const unique = {};
              topic.forEach((topic) => {
                  unique[checkTopic(topic)] = true;
              });
              // The order of OR-topics does not matter
              const sorted = Object.keys(unique);
              sorted.sort();
              return sorted.join("|");
          }
          else {
              return checkTopic(topic);
          }
      }).join("&");
  }
  function deserializeTopics(data) {
      if (data === "") {
          return [];
      }
      return data.split(/&/g).map((topic) => {
          if (topic === "") {
              return [];
          }
          const comps = topic.split("|").map((topic) => {
              return ((topic === "null") ? null : topic);
          });
          return ((comps.length === 1) ? comps[0] : comps);
      });
  }
  function getEventTag(eventName) {
      if (typeof (eventName) === "string") {
          eventName = eventName.toLowerCase();
          if (hexDataLength(eventName) === 32) {
              return "tx:" + eventName;
          }
          if (eventName.indexOf(":") === -1) {
              return eventName;
          }
      }
      else if (Array.isArray(eventName)) {
          return "filter:*:" + serializeTopics(eventName);
      }
      else if (ForkEvent.isForkEvent(eventName)) {
          logger.warn("not implemented");
          throw new Error("not implemented");
      }
      else if (eventName && typeof (eventName) === "object") {
          return "filter:" + (eventName.address || "*") + ":" + serializeTopics(eventName.topics || []);
      }
      throw new Error("invalid event - " + eventName);
  }
  //////////////////////////////
  // Helper Object
  function getTime() {
      return (new Date()).getTime();
  }
  function stall(duration) {
      return new Promise((resolve) => {
          setTimeout(resolve, duration);
      });
  }
  //////////////////////////////
  // Provider Object
  /**
   *  EventType
   *   - "block"
   *   - "poll"
   *   - "didPoll"
   *   - "pending"
   *   - "error"
   *   - "network"
   *   - filter
   *   - topics array
   *   - transaction hash
   */
  const PollableEvents = ["block", "network", "pending", "poll"];
  export class Event {
      constructor(tag, listener, once) {
          defineReadOnly(this, "tag", tag);
          defineReadOnly(this, "listener", listener);
          defineReadOnly(this, "once", once);
      }
      get event() {
          switch (this.type) {
              case "tx":
                  return this.hash;
              case "filter":
                  return this.filter;
          }
          return this.tag;
      }
      get type() {
          return this.tag.split(":")[0];
      }
      get hash() {
          const comps = this.tag.split(":");
          if (comps[0] !== "tx") {
              return null;
          }
          return comps[1];
      }
      get filter() {
          const comps = this.tag.split(":");
          if (comps[0] !== "filter") {
              return null;
          }
          const address = comps[1];
          const topics = deserializeTopics(comps[2]);
          const filter = {};
          if (topics.length > 0) {
              filter.topics = topics;
          }
          if (address && address !== "*") {
              filter.address = address;
          }
          return filter;
      }
      pollable() {
          return (this.tag.indexOf(":") >= 0 || PollableEvents.indexOf(this.tag) >= 0);
      }
  }
  ;
  // https://github.com/satoshilabs/slips/blob/master/slip-0044.md
  const coinInfos = {
      "0": { symbol: "btc", p2pkh: 0x00, p2sh: 0x05, prefix: "bc" },
      "2": { symbol: "ltc", p2pkh: 0x30, p2sh: 0x32, prefix: "ltc" },
      "3": { symbol: "doge", p2pkh: 0x1e, p2sh: 0x16 },
      "60": { symbol: "eth", ilk: "eth" },
      "61": { symbol: "etc", ilk: "eth" },
      "700": { symbol: "xdai", ilk: "eth" },
  };
  function bytes32ify(value) {
      return hexZeroPad(BigNumber.from(value).toHexString(), 32);
  }
  // Compute the Base58Check encoded data (checksum is first 4 bytes of sha256d)
  function base58Encode(data) {
      return Base58.encode(concat([data, hexDataSlice(sha256(sha256(data)), 0, 4)]));
  }
  export class Resolver {
      constructor(provider, address, name) {
          defineReadOnly(this, "provider", provider);
          defineReadOnly(this, "name", name);
          defineReadOnly(this, "address", provider.formatter.address(address));
      }
      _fetchBytes(selector, parameters) {
          return __awaiter(this, void 0, void 0, function* () {
              // keccak256("addr(bytes32,uint256)")
              const transaction = {
                  to: this.address,
                  data: hexConcat([selector, namehash(this.name), (parameters || "0x")])
              };
              const result = yield this.provider.call(transaction);
              if (result === "0x") {
                  return null;
              }
              const offset = BigNumber.from(hexDataSlice(result, 0, 32)).toNumber();
              const length = BigNumber.from(hexDataSlice(result, offset, offset + 32)).toNumber();
              return hexDataSlice(result, offset + 32, offset + 32 + length);
          });
      }
      _getAddress(coinType, hexBytes) {
          const coinInfo = coinInfos[String(coinType)];
          if (coinInfo == null) {
              logger.throwError(`unsupported coin type: ${coinType}`, Logger.errors.UNSUPPORTED_OPERATION, {
                  operation: `getAddress(${coinType})`
              });
          }
          if (coinInfo.ilk === "eth") {
              return this.provider.formatter.address(hexBytes);
          }
          const bytes = arrayify(hexBytes);
          // P2PKH: OP_DUP OP_HASH160 <pubKeyHash> OP_EQUALVERIFY OP_CHECKSIG
          if (coinInfo.p2pkh != null) {
              const p2pkh = hexBytes.match(/^0x76a9([0-9a-f][0-9a-f])([0-9a-f]*)88ac$/);
              if (p2pkh) {
                  const length = parseInt(p2pkh[1], 16);
                  if (p2pkh[2].length === length * 2 && length >= 1 && length <= 75) {
                      return base58Encode(concat([[coinInfo.p2pkh], ("0x" + p2pkh[2])]));
                  }
              }
          }
          // P2SH: OP_HASH160 <scriptHash> OP_EQUAL
          if (coinInfo.p2sh != null) {
              const p2sh = hexBytes.match(/^0xa9([0-9a-f][0-9a-f])([0-9a-f]*)87$/);
              if (p2sh) {
                  const length = parseInt(p2sh[1], 16);
                  if (p2sh[2].length === length * 2 && length >= 1 && length <= 75) {
                      return base58Encode(concat([[coinInfo.p2sh], ("0x" + p2sh[2])]));
                  }
              }
          }
          // Bech32
          if (coinInfo.prefix != null) {
              const length = bytes[1];
              // https://github.com/bitcoin/bips/blob/master/bip-0141.mediawiki#witness-program
              let version = bytes[0];
              if (version === 0x00) {
                  if (length !== 20 && length !== 32) {
                      version = -1;
                  }
              }
              else {
                  version = -1;
              }
              if (version >= 0 && bytes.length === 2 + length && length >= 1 && length <= 75) {
                  const words = bech32.toWords(bytes.slice(2));
                  words.unshift(version);
                  return bech32.encode(coinInfo.prefix, words);
              }
          }
          return null;
      }
      getAddress(coinType) {
          return __awaiter(this, void 0, void 0, function* () {
              if (coinType == null) {
                  coinType = 60;
              }
              // If Ethereum, use the standard `addr(bytes32)`
              if (coinType === 60) {
                  // keccak256("addr(bytes32)")
                  const transaction = {
                      to: this.address,
                      data: ("0x3b3b57de" + namehash(this.name).substring(2))
                  };
                  const hexBytes = yield this.provider.call(transaction);
                  // No address
                  if (hexBytes === "0x" || hexBytes === HashZero) {
                      return null;
                  }
                  return this.provider.formatter.callAddress(hexBytes);
              }
              // keccak256("addr(bytes32,uint256")
              const hexBytes = yield this._fetchBytes("0xf1cb7e06", bytes32ify(coinType));
              // No address
              if (hexBytes == null || hexBytes === "0x") {
                  return null;
              }
              // Compute the address
              const address = this._getAddress(coinType, hexBytes);
              if (address == null) {
                  logger.throwError(`invalid or unsupported coin data`, Logger.errors.UNSUPPORTED_OPERATION, {
                      operation: `getAddress(${coinType})`,
                      coinType: coinType,
                      data: hexBytes
                  });
              }
              return address;
          });
      }
      getContentHash() {
          return __awaiter(this, void 0, void 0, function* () {
              // keccak256("contenthash()")
              const hexBytes = yield this._fetchBytes("0xbc1c58d1");
              // No contenthash
              if (hexBytes == null || hexBytes === "0x") {
                  return null;
              }
              // IPFS (CID: 1, Type: DAG-PB)
              const ipfs = hexBytes.match(/^0xe3010170(([0-9a-f][0-9a-f])([0-9a-f][0-9a-f])([0-9a-f]*))$/);
              if (ipfs) {
                  const length = parseInt(ipfs[3], 16);
                  if (ipfs[4].length === length * 2) {
                      return "ipfs:/\/" + Base58.encode("0x" + ipfs[1]);
                  }
              }
              // Swarm (CID: 1, Type: swarm-manifest; hash/length hard-coded to keccak256/32)
              const swarm = hexBytes.match(/^0xe40101fa011b20([0-9a-f]*)$/);
              if (swarm) {
                  if (swarm[1].length === (32 * 2)) {
                      return "bzz:/\/" + swarm[1];
                  }
              }
              return logger.throwError(`invalid or unsupported content hash data`, Logger.errors.UNSUPPORTED_OPERATION, {
                  operation: "getContentHash()",
                  data: hexBytes
              });
          });
      }
      getText(key) {
          return __awaiter(this, void 0, void 0, function* () {
              // The key encoded as parameter to fetchBytes
              let keyBytes = toUtf8Bytes(key);
              // The nodehash consumes the first slot, so the string pointer targets
              // offset 64, with the length at offset 64 and data starting at offset 96
              keyBytes = concat([bytes32ify(64), bytes32ify(keyBytes.length), keyBytes]);
              // Pad to word-size (32 bytes)
              if ((keyBytes.length % 32) !== 0) {
                  keyBytes = concat([keyBytes, hexZeroPad("0x", 32 - (key.length % 32))]);
              }
              const hexBytes = yield this._fetchBytes("0x59d1d43c", hexlify(keyBytes));
              if (hexBytes == null || hexBytes === "0x") {
                  return null;
              }
              return toUtf8String(hexBytes);
          });
      }
  }
  let defaultFormatter = null;
  let nextPollId = 1;
  export class BaseProvider extends Provider {
      /**
       *  ready
       *
       *  A Promise<Network> that resolves only once the provider is ready.
       *
       *  Sub-classes that call the super with a network without a chainId
       *  MUST set this. Standard named networks have a known chainId.
       *
       */
      constructor(network) {
          logger.checkNew(new.target, Provider);
          super();
          // Events being listened to
          this._events = [];
          this._emitted = { block: -2 };
          this.formatter = new.target.getFormatter();
          // If network is any, this Provider allows the underlying
          // network to change dynamically, and we auto-detect the
          // current network
          defineReadOnly(this, "anyNetwork", (network === "any"));
          if (this.anyNetwork) {
              network = this.detectNetwork();
          }
          if (network instanceof Promise) {
              this._networkPromise = network;
              // Squash any "unhandled promise" errors; that do not need to be handled
              network.catch((error) => { });
              // Trigger initial network setting (async)
              this._ready().catch((error) => { });
          }
          else {
              const knownNetwork = getStatic((new.target), "getNetwork")(network);
              if (knownNetwork) {
                  defineReadOnly(this, "_network", knownNetwork);
                  this.emit("network", knownNetwork, null);
              }
              else {
                  logger.throwArgumentError("invalid network", "network", network);
              }
          }
          this._maxInternalBlockNumber = -1024;
          this._lastBlockNumber = -2;
          this._pollingInterval = 4000;
          this._fastQueryDate = 0;
      }
      _ready() {
          return __awaiter(this, void 0, void 0, function* () {
              if (this._network == null) {
                  let network = null;
                  if (this._networkPromise) {
                      try {
                          network = yield this._networkPromise;
                      }
                      catch (error) { }
                  }
                  // Try the Provider's network detection (this MUST throw if it cannot)
                  if (network == null) {
                      network = yield this.detectNetwork();
                  }
                  // This should never happen; every Provider sub-class should have
                  // suggested a network by here (or have thrown).
                  if (!network) {
                      logger.throwError("no network detected", Logger.errors.UNKNOWN_ERROR, {});
                  }
                  // Possible this call stacked so do not call defineReadOnly again
                  if (this._network == null) {
                      if (this.anyNetwork) {
                          this._network = network;
                      }
                      else {
                          defineReadOnly(this, "_network", network);
                      }
                      this.emit("network", network, null);
                  }
              }
              return this._network;
          });
      }
      // This will always return the most recently established network.
      // For "any", this can change (a "network" event is emitted before
      // any change is refelcted); otherwise this cannot change
      get ready() {
          return poll(() => {
              return this._ready().then((network) => {
                  return network;
              }, (error) => {
                  // If the network isn't running yet, we will wait
                  if (error.code === Logger.errors.NETWORK_ERROR && error.event === "noNetwork") {
                      return undefined;
                  }
                  throw error;
              });
          });
      }
      // @TODO: Remove this and just create a singleton formatter
      static getFormatter() {
          if (defaultFormatter == null) {
              defaultFormatter = new Formatter();
          }
          return defaultFormatter;
      }
      // @TODO: Remove this and just use getNetwork
      static getNetwork(network) {
          return getNetwork((network == null) ? "homestead" : network);
      }
      // Fetches the blockNumber, but will reuse any result that is less
      // than maxAge old or has been requested since the last request
      _getInternalBlockNumber(maxAge) {
          return __awaiter(this, void 0, void 0, function* () {
              yield this._ready();
              // Allowing stale data up to maxAge old
              if (maxAge > 0) {
                  // While there are pending internal block requests...
                  while (this._internalBlockNumber) {
                      // ..."remember" which fetch we started with
                      const internalBlockNumber = this._internalBlockNumber;
                      try {
                          // Check the result is not too stale
                          const result = yield internalBlockNumber;
                          if ((getTime() - result.respTime) <= maxAge) {
                              return result.blockNumber;
                          }
                          // Too old; fetch a new value
                          break;
                      }
                      catch (error) {
                          // The fetch rejected; if we are the first to get the
                          // rejection, drop through so we replace it with a new
                          // fetch; all others blocked will then get that fetch
                          // which won't match the one they "remembered" and loop
                          if (this._internalBlockNumber === internalBlockNumber) {
                              break;
                          }
                      }
                  }
              }
              const reqTime = getTime();
              const checkInternalBlockNumber = resolveProperties({
                  blockNumber: this.perform("getBlockNumber", {}),
                  networkError: this.getNetwork().then((network) => (null), (error) => (error))
              }).then(({ blockNumber, networkError }) => {
                  if (networkError) {
                      // Unremember this bad internal block number
                      if (this._internalBlockNumber === checkInternalBlockNumber) {
                          this._internalBlockNumber = null;
                      }
                      throw networkError;
                  }
                  const respTime = getTime();
                  blockNumber = BigNumber.from(blockNumber).toNumber();
                  if (blockNumber < this._maxInternalBlockNumber) {
                      blockNumber = this._maxInternalBlockNumber;
                  }
                  this._maxInternalBlockNumber = blockNumber;
                  this._setFastBlockNumber(blockNumber); // @TODO: Still need this?
                  return { blockNumber, reqTime, respTime };
              });
              this._internalBlockNumber = checkInternalBlockNumber;
              // Swallow unhandled exceptions; if needed they are handled else where
              checkInternalBlockNumber.catch((error) => {
                  // Don't null the dead (rejected) fetch, if it has already been updated
                  if (this._internalBlockNumber === checkInternalBlockNumber) {
                      this._internalBlockNumber = null;
                  }
              });
              return (yield checkInternalBlockNumber).blockNumber;
          });
      }
      poll() {
          return __awaiter(this, void 0, void 0, function* () {
              const pollId = nextPollId++;
              // Track all running promises, so we can trigger a post-poll once they are complete
              const runners = [];
              let blockNumber = null;
              try {
                  blockNumber = yield this._getInternalBlockNumber(100 + this.pollingInterval / 2);
              }
              catch (error) {
                  this.emit("error", error);
                  return;
              }
              this._setFastBlockNumber(blockNumber);
              // Emit a poll event after we have the latest (fast) block number
              this.emit("poll", pollId, blockNumber);
              // If the block has not changed, meh.
              if (blockNumber === this._lastBlockNumber) {
                  this.emit("didPoll", pollId);
                  return;
              }
              // First polling cycle, trigger a "block" events
              if (this._emitted.block === -2) {
                  this._emitted.block = blockNumber - 1;
              }
              if (Math.abs((this._emitted.block) - blockNumber) > 1000) {
                  logger.warn(`network block skew detected; skipping block events (emitted=${this._emitted.block} blockNumber${blockNumber})`);
                  this.emit("error", logger.makeError("network block skew detected", Logger.errors.NETWORK_ERROR, {
                      blockNumber: blockNumber,
                      event: "blockSkew",
                      previousBlockNumber: this._emitted.block
                  }));
                  this.emit("block", blockNumber);
              }
              else {
                  // Notify all listener for each block that has passed
                  for (let i = this._emitted.block + 1; i <= blockNumber; i++) {
                      this.emit("block", i);
                  }
              }
              // The emitted block was updated, check for obsolete events
              if (this._emitted.block !== blockNumber) {
                  this._emitted.block = blockNumber;
                  Object.keys(this._emitted).forEach((key) => {
                      // The block event does not expire
                      if (key === "block") {
                          return;
                      }
                      // The block we were at when we emitted this event
                      const eventBlockNumber = this._emitted[key];
                      // We cannot garbage collect pending transactions or blocks here
                      // They should be garbage collected by the Provider when setting
                      // "pending" events
                      if (eventBlockNumber === "pending") {
                          return;
                      }
                      // Evict any transaction hashes or block hashes over 12 blocks
                      // old, since they should not return null anyways
                      if (blockNumber - eventBlockNumber > 12) {
                          delete this._emitted[key];
                      }
                  });
              }
              // First polling cycle
              if (this._lastBlockNumber === -2) {
                  this._lastBlockNumber = blockNumber - 1;
              }
              // Find all transaction hashes we are waiting on
              this._events.forEach((event) => {
                  switch (event.type) {
                      case "tx": {
                          const hash = event.hash;
                          let runner = this.getTransactionReceipt(hash).then((receipt) => {
                              if (!receipt || receipt.blockNumber == null) {
                                  return null;
                              }
                              this._emitted["t:" + hash] = receipt.blockNumber;
                              this.emit(hash, receipt);
                              return null;
                          }).catch((error) => { this.emit("error", error); });
                          runners.push(runner);
                          break;
                      }
                      case "filter": {
                          const filter = event.filter;
                          filter.fromBlock = this._lastBlockNumber + 1;
                          filter.toBlock = blockNumber;
                          const runner = this.getLogs(filter).then((logs) => {
                              if (logs.length === 0) {
                                  return;
                              }
                              logs.forEach((log) => {
                                  this._emitted["b:" + log.blockHash] = log.blockNumber;
                                  this._emitted["t:" + log.transactionHash] = log.blockNumber;
                                  this.emit(filter, log);
                              });
                          }).catch((error) => { this.emit("error", error); });
                          runners.push(runner);
                          break;
                      }
                  }
              });
              this._lastBlockNumber = blockNumber;
              // Once all events for this loop have been processed, emit "didPoll"
              Promise.all(runners).then(() => {
                  this.emit("didPoll", pollId);
              }).catch((error) => { this.emit("error", error); });
              return;
          });
      }
      // Deprecated; do not use this
      resetEventsBlock(blockNumber) {
          this._lastBlockNumber = blockNumber - 1;
          if (this.polling) {
              this.poll();
          }
      }
      get network() {
          return this._network;
      }
      // This method should query the network if the underlying network
      // can change, such as when connected to a JSON-RPC backend
      detectNetwork() {
          return __awaiter(this, void 0, void 0, function* () {
              return logger.throwError("provider does not support network detection", Logger.errors.UNSUPPORTED_OPERATION, {
                  operation: "provider.detectNetwork"
              });
          });
      }
      getNetwork() {
          return __awaiter(this, void 0, void 0, function* () {
              const network = yield this._ready();
              // Make sure we are still connected to the same network; this is
              // only an external call for backends which can have the underlying
              // network change spontaneously
              const currentNetwork = yield this.detectNetwork();
              if (network.chainId !== currentNetwork.chainId) {
                  // We are allowing network changes, things can get complex fast;
                  // make sure you know what you are doing if you use "any"
                  if (this.anyNetwork) {
                      this._network = currentNetwork;
                      // Reset all internal block number guards and caches
                      this._lastBlockNumber = -2;
                      this._fastBlockNumber = null;
                      this._fastBlockNumberPromise = null;
                      this._fastQueryDate = 0;
                      this._emitted.block = -2;
                      this._maxInternalBlockNumber = -1024;
                      this._internalBlockNumber = null;
                      // The "network" event MUST happen before this method resolves
                      // so any events have a chance to unregister, so we stall an
                      // additional event loop before returning from /this/ call
                      this.emit("network", currentNetwork, network);
                      yield stall(0);
                      return this._network;
                  }
                  const error = logger.makeError("underlying network changed", Logger.errors.NETWORK_ERROR, {
                      event: "changed",
                      network: network,
                      detectedNetwork: currentNetwork
                  });
                  this.emit("error", error);
                  throw error;
              }
              return network;
          });
      }
      get blockNumber() {
          this._getInternalBlockNumber(100 + this.pollingInterval / 2).then((blockNumber) => {
              this._setFastBlockNumber(blockNumber);
          }, (error) => { });
          return (this._fastBlockNumber != null) ? this._fastBlockNumber : -1;
      }
      get polling() {
          return (this._poller != null);
      }
      set polling(value) {
          if (value && !this._poller) {
              this._poller = setInterval(() => { this.poll(); }, this.pollingInterval);
              if (!this._bootstrapPoll) {
                  this._bootstrapPoll = setTimeout(() => {
                      this.poll();
                      // We block additional polls until the polling interval
                      // is done, to prevent overwhelming the poll function
                      this._bootstrapPoll = setTimeout(() => {
                          // If polling was disabled, something may require a poke
                          // since starting the bootstrap poll and it was disabled
                          if (!this._poller) {
                              this.poll();
                          }
                          // Clear out the bootstrap so we can do another
                          this._bootstrapPoll = null;
                      }, this.pollingInterval);
                  }, 0);
              }
          }
          else if (!value && this._poller) {
              clearInterval(this._poller);
              this._poller = null;
          }
      }
      get pollingInterval() {
          return this._pollingInterval;
      }
      set pollingInterval(value) {
          if (typeof (value) !== "number" || value <= 0 || parseInt(String(value)) != value) {
              throw new Error("invalid polling interval");
          }
          this._pollingInterval = value;
          if (this._poller) {
              clearInterval(this._poller);
              this._poller = setInterval(() => { this.poll(); }, this._pollingInterval);
          }
      }
      _getFastBlockNumber() {
          const now = getTime();
          // Stale block number, request a newer value
          if ((now - this._fastQueryDate) > 2 * this._pollingInterval) {
              this._fastQueryDate = now;
              this._fastBlockNumberPromise = this.getBlockNumber().then((blockNumber) => {
                  if (this._fastBlockNumber == null || blockNumber > this._fastBlockNumber) {
                      this._fastBlockNumber = blockNumber;
                  }
                  return this._fastBlockNumber;
              });
          }
          return this._fastBlockNumberPromise;
      }
      _setFastBlockNumber(blockNumber) {
          // Older block, maybe a stale request
          if (this._fastBlockNumber != null && blockNumber < this._fastBlockNumber) {
              return;
          }
          // Update the time we updated the blocknumber
          this._fastQueryDate = getTime();
          // Newer block number, use  it
          if (this._fastBlockNumber == null || blockNumber > this._fastBlockNumber) {
              this._fastBlockNumber = blockNumber;
              this._fastBlockNumberPromise = Promise.resolve(blockNumber);
          }
      }
      waitForTransaction(transactionHash, confirmations, timeout) {
          return __awaiter(this, void 0, void 0, function* () {
              return this._waitForTransaction(transactionHash, (confirmations == null) ? 1 : confirmations, timeout || 0, null);
          });
      }
      _waitForTransaction(transactionHash, confirmations, timeout, replaceable) {
          return __awaiter(this, void 0, void 0, function* () {
              const receipt = yield this.getTransactionReceipt(transactionHash);
              // Receipt is already good
              if ((receipt ? receipt.confirmations : 0) >= confirmations) {
                  return receipt;
              }
              // Poll until the receipt is good...
              return new Promise((resolve, reject) => {
                  const cancelFuncs = [];
                  let done = false;
                  const alreadyDone = function () {
                      if (done) {
                          return true;
                      }
                      done = true;
                      cancelFuncs.forEach((func) => { func(); });
                      return false;
                  };
                  const minedHandler = (receipt) => {
                      if (receipt.confirmations < confirmations) {
                          return;
                      }
                      if (alreadyDone()) {
                          return;
                      }
                      resolve(receipt);
                  };
                  this.on(transactionHash, minedHandler);
                  cancelFuncs.push(() => { this.removeListener(transactionHash, minedHandler); });
                  if (replaceable) {
                      let lastBlockNumber = replaceable.startBlock;
                      let scannedBlock = null;
                      const replaceHandler = (blockNumber) => __awaiter(this, void 0, void 0, function* () {
                          if (done) {
                              return;
                          }
                          // Wait 1 second; this is only used in the case of a fault, so
                          // we will trade off a little bit of latency for more consistent
                          // results and fewer JSON-RPC calls
                          yield stall(1000);
                          this.getTransactionCount(replaceable.from).then((nonce) => __awaiter(this, void 0, void 0, function* () {
                              if (done) {
                                  return;
                              }
                              if (nonce <= replaceable.nonce) {
                                  lastBlockNumber = blockNumber;
                              }
                              else {
                                  // First check if the transaction was mined
                                  {
                                      const mined = yield this.getTransaction(transactionHash);
                                      if (mined && mined.blockNumber != null) {
                                          return;
                                      }
                                  }
                                  // First time scanning. We start a little earlier for some
                                  // wiggle room here to handle the eventually consistent nature
                                  // of blockchain (e.g. the getTransactionCount was for a
                                  // different block)
                                  if (scannedBlock == null) {
                                      scannedBlock = lastBlockNumber - 3;
                                      if (scannedBlock < replaceable.startBlock) {
                                          scannedBlock = replaceable.startBlock;
                                      }
                                  }
                                  while (scannedBlock <= blockNumber) {
                                      if (done) {
                                          return;
                                      }
                                      const block = yield this.getBlockWithTransactions(scannedBlock);
                                      for (let ti = 0; ti < block.transactions.length; ti++) {
                                          const tx = block.transactions[ti];
                                          // Successfully mined!
                                          if (tx.hash === transactionHash) {
                                              return;
                                          }
                                          // Matches our transaction from and nonce; its a replacement
                                          if (tx.from === replaceable.from && tx.nonce === replaceable.nonce) {
                                              if (done) {
                                                  return;
                                              }
                                              // Get the receipt of the replacement
                                              const receipt = yield this.waitForTransaction(tx.hash, confirmations);
                                              // Already resolved or rejected (prolly a timeout)
                                              if (alreadyDone()) {
                                                  return;
                                              }
                                              // The reason we were replaced
                                              let reason = "replaced";
                                              if (tx.data === replaceable.data && tx.to === replaceable.to && tx.value.eq(replaceable.value)) {
                                                  reason = "repriced";
                                              }
                                              else if (tx.data === "0x" && tx.from === tx.to && tx.value.isZero()) {
                                                  reason = "cancelled";
                                              }
                                              // Explain why we were replaced
                                              reject(logger.makeError("transaction was replaced", Logger.errors.TRANSACTION_REPLACED, {
                                                  cancelled: (reason === "replaced" || reason === "cancelled"),
                                                  reason,
                                                  replacement: this._wrapTransaction(tx),
                                                  hash: transactionHash,
                                                  receipt
                                              }));
                                              return;
                                          }
                                      }
                                      scannedBlock++;
                                  }
                              }
                              if (done) {
                                  return;
                              }
                              this.once("block", replaceHandler);
                          }), (error) => {
                              if (done) {
                                  return;
                              }
                              this.once("block", replaceHandler);
                          });
                      });
                      if (done) {
                          return;
                      }
                      this.once("block", replaceHandler);
                      cancelFuncs.push(() => {
                          this.removeListener("block", replaceHandler);
                      });
                  }
                  if (typeof (timeout) === "number" && timeout > 0) {
                      const timer = setTimeout(() => {
                          if (alreadyDone()) {
                              return;
                          }
                          reject(logger.makeError("timeout exceeded", Logger.errors.TIMEOUT, { timeout: timeout }));
                      }, timeout);
                      if (timer.unref) {
                          timer.unref();
                      }
                      cancelFuncs.push(() => { clearTimeout(timer); });
                  }
              });
          });
      }
      getBlockNumber() {
          return __awaiter(this, void 0, void 0, function* () {
              return this._getInternalBlockNumber(0);
          });
      }
      getGasPrice() {
          return __awaiter(this, void 0, void 0, function* () {
              yield this.getNetwork();
              const result = yield this.perform("getGasPrice", {});
              try {
                  return BigNumber.from(result);
              }
              catch (error) {
                  return logger.throwError("bad result from backend", Logger.errors.SERVER_ERROR, {
                      method: "getGasPrice",
                      result, error
                  });
              }
          });
      }
      getBalance(addressOrName, blockTag) {
          return __awaiter(this, void 0, void 0, function* () {
              yield this.getNetwork();
              const params = yield resolveProperties({
                  address: this._getAddress(addressOrName),
                  blockTag: this._getBlockTag(blockTag)
              });
              const result = yield this.perform("getBalance", params);
              try {
                  return BigNumber.from(result);
              }
              catch (error) {
                  return logger.throwError("bad result from backend", Logger.errors.SERVER_ERROR, {
                      method: "getBalance",
                      params, result, error
                  });
              }
          });
      }
      getTransactionCount(addressOrName, blockTag) {
          return __awaiter(this, void 0, void 0, function* () {
              yield this.getNetwork();
              const params = yield resolveProperties({
                  address: this._getAddress(addressOrName),
                  blockTag: this._getBlockTag(blockTag)
              });
              const result = yield this.perform("getTransactionCount", params);
              try {
                  return BigNumber.from(result).toNumber();
              }
              catch (error) {
                  return logger.throwError("bad result from backend", Logger.errors.SERVER_ERROR, {
                      method: "getTransactionCount",
                      params, result, error
                  });
              }
          });
      }
      getCode(addressOrName, blockTag) {
          return __awaiter(this, void 0, void 0, function* () {
              yield this.getNetwork();
              const params = yield resolveProperties({
                  address: this._getAddress(addressOrName),
                  blockTag: this._getBlockTag(blockTag)
              });
              const result = yield this.perform("getCode", params);
              try {
                  return hexlify(result);
              }
              catch (error) {
                  return logger.throwError("bad result from backend", Logger.errors.SERVER_ERROR, {
                      method: "getCode",
                      params, result, error
                  });
              }
          });
      }
      getStorageAt(addressOrName, position, blockTag) {
          return __awaiter(this, void 0, void 0, function* () {
              yield this.getNetwork();
              const params = yield resolveProperties({
                  address: this._getAddress(addressOrName),
                  blockTag: this._getBlockTag(blockTag),
                  position: Promise.resolve(position).then((p) => hexValue(p))
              });
              const result = yield this.perform("getStorageAt", params);
              try {
                  return hexlify(result);
              }
              catch (error) {
                  return logger.throwError("bad result from backend", Logger.errors.SERVER_ERROR, {
                      method: "getStorageAt",
                      params, result, error
                  });
              }
          });
      }
      // This should be called by any subclass wrapping a TransactionResponse
      _wrapTransaction(tx, hash, startBlock) {
          if (hash != null && hexDataLength(hash) !== 32) {
              throw new Error("invalid response - sendTransaction");
          }
          const result = tx;
          // Check the hash we expect is the same as the hash the server reported
          if (hash != null && tx.hash !== hash) {
              logger.throwError("Transaction hash mismatch from Provider.sendTransaction.", Logger.errors.UNKNOWN_ERROR, { expectedHash: tx.hash, returnedHash: hash });
          }
          result.wait = (confirms, timeout) => __awaiter(this, void 0, void 0, function* () {
              if (confirms == null) {
                  confirms = 1;
              }
              if (timeout == null) {
                  timeout = 0;
              }
              // Get the details to detect replacement
              let replacement = undefined;
              if (confirms !== 0 && startBlock != null) {
                  replacement = {
                      data: tx.data,
                      from: tx.from,
                      nonce: tx.nonce,
                      to: tx.to,
                      value: tx.value,
                      startBlock
                  };
              }
              const receipt = yield this._waitForTransaction(tx.hash, confirms, timeout, replacement);
              if (receipt == null && confirms === 0) {
                  return null;
              }
              // No longer pending, allow the polling loop to garbage collect this
              this._emitted["t:" + tx.hash] = receipt.blockNumber;
              if (receipt.status === 0) {
                  logger.throwError("transaction failed", Logger.errors.CALL_EXCEPTION, {
                      transactionHash: tx.hash,
                      transaction: tx,
                      receipt: receipt
                  });
              }
              return receipt;
          });
          return result;
      }
      sendTransaction(signedTransaction) {
          return __awaiter(this, void 0, void 0, function* () {
              yield this.getNetwork();
              const hexTx = yield Promise.resolve(signedTransaction).then(t => hexlify(t));
              const tx = this.formatter.transaction(signedTransaction);
              const blockNumber = yield this._getInternalBlockNumber(100 + 2 * this.pollingInterval);
              try {
                  const hash = yield this.perform("sendTransaction", { signedTransaction: hexTx });
                  return this._wrapTransaction(tx, hash, blockNumber);
              }
              catch (error) {
                  error.transaction = tx;
                  error.transactionHash = tx.hash;
                  throw error;
              }
          });
      }
      _getTransactionRequest(transaction) {
          return __awaiter(this, void 0, void 0, function* () {
              const values = yield transaction;
              const tx = {};
              ["from", "to"].forEach((key) => {
                  if (values[key] == null) {
                      return;
                  }
                  tx[key] = Promise.resolve(values[key]).then((v) => (v ? this._getAddress(v) : null));
              });
              ["gasLimit", "gasPrice", "value"].forEach((key) => {
                  if (values[key] == null) {
                      return;
                  }
                  tx[key] = Promise.resolve(values[key]).then((v) => (v ? BigNumber.from(v) : null));
              });
              ["type"].forEach((key) => {
                  if (values[key] == null) {
                      return;
                  }
                  tx[key] = Promise.resolve(values[key]).then((v) => ((v != null) ? v : null));
              });
              if (values.accessList) {
                  tx.accessList = this.formatter.accessList(values.accessList);
              }
              ["data"].forEach((key) => {
                  if (values[key] == null) {
                      return;
                  }
                  tx[key] = Promise.resolve(values[key]).then((v) => (v ? hexlify(v) : null));
              });
              return this.formatter.transactionRequest(yield resolveProperties(tx));
          });
      }
      _getFilter(filter) {
          return __awaiter(this, void 0, void 0, function* () {
              filter = yield filter;
              const result = {};
              if (filter.address != null) {
                  result.address = this._getAddress(filter.address);
              }
              ["blockHash", "topics"].forEach((key) => {
                  if (filter[key] == null) {
                      return;
                  }
                  result[key] = filter[key];
              });
              ["fromBlock", "toBlock"].forEach((key) => {
                  if (filter[key] == null) {
                      return;
                  }
                  result[key] = this._getBlockTag(filter[key]);
              });
              return this.formatter.filter(yield resolveProperties(result));
          });
      }
      call(transaction, blockTag) {
          return __awaiter(this, void 0, void 0, function* () {
              yield this.getNetwork();
              const params = yield resolveProperties({
                  transaction: this._getTransactionRequest(transaction),
                  blockTag: this._getBlockTag(blockTag)
              });
              const result = yield this.perform("call", params);
              try {
                  return hexlify(result);
              }
              catch (error) {
                  return logger.throwError("bad result from backend", Logger.errors.SERVER_ERROR, {
                      method: "call",
                      params, result, error
                  });
              }
          });
      }
      estimateGas(transaction) {
          return __awaiter(this, void 0, void 0, function* () {
              yield this.getNetwork();
              const params = yield resolveProperties({
                  transaction: this._getTransactionRequest(transaction)
              });
              const result = yield this.perform("estimateGas", params);
              try {
                  return BigNumber.from(result);
              }
              catch (error) {
                  return logger.throwError("bad result from backend", Logger.errors.SERVER_ERROR, {
                      method: "estimateGas",
                      params, result, error
                  });
              }
          });
      }
      _getAddress(addressOrName) {
          return __awaiter(this, void 0, void 0, function* () {
              const address = yield this.resolveName(addressOrName);
              if (address == null) {
                  logger.throwError("ENS name not configured", Logger.errors.UNSUPPORTED_OPERATION, {
                      operation: `resolveName(${JSON.stringify(addressOrName)})`
                  });
              }
              return address;
          });
      }
      _getBlock(blockHashOrBlockTag, includeTransactions) {
          return __awaiter(this, void 0, void 0, function* () {
              yield this.getNetwork();
              blockHashOrBlockTag = yield blockHashOrBlockTag;
              // If blockTag is a number (not "latest", etc), this is the block number
              let blockNumber = -128;
              const params = {
                  includeTransactions: !!includeTransactions
              };
              if (isHexString(blockHashOrBlockTag, 32)) {
                  params.blockHash = blockHashOrBlockTag;
              }
              else {
                  try {
                      params.blockTag = this.formatter.blockTag(yield this._getBlockTag(blockHashOrBlockTag));
                      if (isHexString(params.blockTag)) {
                          blockNumber = parseInt(params.blockTag.substring(2), 16);
                      }
                  }
                  catch (error) {
                      logger.throwArgumentError("invalid block hash or block tag", "blockHashOrBlockTag", blockHashOrBlockTag);
                  }
              }
              return poll(() => __awaiter(this, void 0, void 0, function* () {
                  const block = yield this.perform("getBlock", params);
                  // Block was not found
                  if (block == null) {
                      // For blockhashes, if we didn't say it existed, that blockhash may
                      // not exist. If we did see it though, perhaps from a log, we know
                      // it exists, and this node is just not caught up yet.
                      if (params.blockHash != null) {
                          if (this._emitted["b:" + params.blockHash] == null) {
                              return null;
                          }
                      }
                      // For block tags, if we are asking for a future block, we return null
                      if (params.blockTag != null) {
                          if (blockNumber > this._emitted.block) {
                              return null;
                          }
                      }
                      // Retry on the next block
                      return undefined;
                  }
                  // Add transactions
                  if (includeTransactions) {
                      let blockNumber = null;
                      for (let i = 0; i < block.transactions.length; i++) {
                          const tx = block.transactions[i];
                          if (tx.blockNumber == null) {
                              tx.confirmations = 0;
                          }
                          else if (tx.confirmations == null) {
                              if (blockNumber == null) {
                                  blockNumber = yield this._getInternalBlockNumber(100 + 2 * this.pollingInterval);
                              }
                              // Add the confirmations using the fast block number (pessimistic)
                              let confirmations = (blockNumber - tx.blockNumber) + 1;
                              if (confirmations <= 0) {
                                  confirmations = 1;
                              }
                              tx.confirmations = confirmations;
                          }
                      }
                      return this.formatter.blockWithTransactions(block);
                  }
                  return this.formatter.block(block);
              }), { oncePoll: this });
          });
      }
      getBlock(blockHashOrBlockTag) {
          return (this._getBlock(blockHashOrBlockTag, false));
      }
      getBlockWithTransactions(blockHashOrBlockTag) {
          return (this._getBlock(blockHashOrBlockTag, true));
      }
      getTransaction(transactionHash) {
          return __awaiter(this, void 0, void 0, function* () {
              yield this.getNetwork();
              transactionHash = yield transactionHash;
              const params = { transactionHash: this.formatter.hash(transactionHash, true) };
              return poll(() => __awaiter(this, void 0, void 0, function* () {
                  const result = yield this.perform("getTransaction", params);
                  if (result == null) {
                      if (this._emitted["t:" + transactionHash] == null) {
                          return null;
                      }
                      return undefined;
                  }
                  const tx = this.formatter.transactionResponse(result);
                  if (tx.blockNumber == null) {
                      tx.confirmations = 0;
                  }
                  else if (tx.confirmations == null) {
                      const blockNumber = yield this._getInternalBlockNumber(100 + 2 * this.pollingInterval);
                      // Add the confirmations using the fast block number (pessimistic)
                      let confirmations = (blockNumber - tx.blockNumber) + 1;
                      if (confirmations <= 0) {
                          confirmations = 1;
                      }
                      tx.confirmations = confirmations;
                  }
                  return this._wrapTransaction(tx);
              }), { oncePoll: this });
          });
      }
      getTransactionReceipt(transactionHash) {
          return __awaiter(this, void 0, void 0, function* () {
              yield this.getNetwork();
              transactionHash = yield transactionHash;
              const params = { transactionHash: this.formatter.hash(transactionHash, true) };
              return poll(() => __awaiter(this, void 0, void 0, function* () {
                  const result = yield this.perform("getTransactionReceipt", params);
                  if (result == null) {
                      if (this._emitted["t:" + transactionHash] == null) {
                          return null;
                      }
                      return undefined;
                  }
                  // "geth-etc" returns receipts before they are ready
                  if (result.blockHash == null) {
                      return undefined;
                  }
                  const receipt = this.formatter.receipt(result);
                  if (receipt.blockNumber == null) {
                      receipt.confirmations = 0;
                  }
                  else if (receipt.confirmations == null) {
                      const blockNumber = yield this._getInternalBlockNumber(100 + 2 * this.pollingInterval);
                      // Add the confirmations using the fast block number (pessimistic)
                      let confirmations = (blockNumber - receipt.blockNumber) + 1;
                      if (confirmations <= 0) {
                          confirmations = 1;
                      }
                      receipt.confirmations = confirmations;
                  }
                  return receipt;
              }), { oncePoll: this });
          });
      }
      getLogs(filter) {
          return __awaiter(this, void 0, void 0, function* () {
              yield this.getNetwork();
              const params = yield resolveProperties({ filter: this._getFilter(filter) });
              const logs = yield this.perform("getLogs", params);
              logs.forEach((log) => {
                  if (log.removed == null) {
                      log.removed = false;
                  }
              });
              return Formatter.arrayOf(this.formatter.filterLog.bind(this.formatter))(logs);
          });
      }
      getEtherPrice() {
          return __awaiter(this, void 0, void 0, function* () {
              yield this.getNetwork();
              return this.perform("getEtherPrice", {});
          });
      }
      _getBlockTag(blockTag) {
          return __awaiter(this, void 0, void 0, function* () {
              blockTag = yield blockTag;
              if (typeof (blockTag) === "number" && blockTag < 0) {
                  if (blockTag % 1) {
                      logger.throwArgumentError("invalid BlockTag", "blockTag", blockTag);
                  }
                  let blockNumber = yield this._getInternalBlockNumber(100 + 2 * this.pollingInterval);
                  blockNumber += blockTag;
                  if (blockNumber < 0) {
                      blockNumber = 0;
                  }
                  return this.formatter.blockTag(blockNumber);
              }
              return this.formatter.blockTag(blockTag);
          });
      }
      getResolver(name) {
          return __awaiter(this, void 0, void 0, function* () {
              const address = yield this._getResolver(name);
              if (address == null) {
                  return null;
              }
              return new Resolver(this, address, name);
          });
      }
      _getResolver(name) {
          return __awaiter(this, void 0, void 0, function* () {
              // Get the resolver from the blockchain
              const network = yield this.getNetwork();
              // No ENS...
              if (!network.ensAddress) {
                  logger.throwError("network does not support ENS", Logger.errors.UNSUPPORTED_OPERATION, { operation: "ENS", network: network.name });
              }
              // keccak256("resolver(bytes32)")
              const transaction = {
                  to: network.ensAddress,
                  data: ("0x0178b8bf" + namehash(name).substring(2))
              };
              return this.formatter.callAddress(yield this.call(transaction));
          });
      }
      resolveName(name) {
          return __awaiter(this, void 0, void 0, function* () {
              name = yield name;
              // If it is already an address, nothing to resolve
              try {
                  return Promise.resolve(this.formatter.address(name));
              }
              catch (error) {
                  // If is is a hexstring, the address is bad (See #694)
                  if (isHexString(name)) {
                      throw error;
                  }
              }
              if (typeof (name) !== "string") {
                  logger.throwArgumentError("invalid ENS name", "name", name);
              }
              // Get the addr from the resovler
              const resolver = yield this.getResolver(name);
              if (!resolver) {
                  return null;
              }
              return yield resolver.getAddress();
          });
      }
      lookupAddress(address) {
          return __awaiter(this, void 0, void 0, function* () {
              address = yield address;
              address = this.formatter.address(address);
              const reverseName = address.substring(2).toLowerCase() + ".addr.reverse";
              const resolverAddress = yield this._getResolver(reverseName);
              if (!resolverAddress) {
                  return null;
              }
              // keccak("name(bytes32)")
              let bytes = arrayify(yield this.call({
                  to: resolverAddress,
                  data: ("0x691f3431" + namehash(reverseName).substring(2))
              }));
              // Strip off the dynamic string pointer (0x20)
              if (bytes.length < 32 || !BigNumber.from(bytes.slice(0, 32)).eq(32)) {
                  return null;
              }
              bytes = bytes.slice(32);
              // Not a length-prefixed string
              if (bytes.length < 32) {
                  return null;
              }
              // Get the length of the string (from the length-prefix)
              const length = BigNumber.from(bytes.slice(0, 32)).toNumber();
              bytes = bytes.slice(32);
              // Length longer than available data
              if (length > bytes.length) {
                  return null;
              }
              const name = toUtf8String(bytes.slice(0, length));
              // Make sure the reverse record matches the foward record
              const addr = yield this.resolveName(name);
              if (addr != address) {
                  return null;
              }
              return name;
          });
      }
      perform(method, params) {
          return logger.throwError(method + " not implemented", Logger.errors.NOT_IMPLEMENTED, { operation: method });
      }
      _startEvent(event) {
          this.polling = (this._events.filter((e) => e.pollable()).length > 0);
      }
      _stopEvent(event) {
          this.polling = (this._events.filter((e) => e.pollable()).length > 0);
      }
      _addEventListener(eventName, listener, once) {
          const event = new Event(getEventTag(eventName), listener, once);
          this._events.push(event);
          this._startEvent(event);
          return this;
      }
      on(eventName, listener) {
          return this._addEventListener(eventName, listener, false);
      }
      once(eventName, listener) {
          return this._addEventListener(eventName, listener, true);
      }
      emit(eventName, ...args) {
          let result = false;
          let stopped = [];
          let eventTag = getEventTag(eventName);
          this._events = this._events.filter((event) => {
              if (event.tag !== eventTag) {
                  return true;
              }
              setTimeout(() => {
                  event.listener.apply(this, args);
              }, 0);
              result = true;
              if (event.once) {
                  stopped.push(event);
                  return false;
              }
              return true;
          });
          stopped.forEach((event) => { this._stopEvent(event); });
          return result;
      }
      listenerCount(eventName) {
          if (!eventName) {
              return this._events.length;
          }
          let eventTag = getEventTag(eventName);
          return this._events.filter((event) => {
              return (event.tag === eventTag);
          }).length;
      }
      listeners(eventName) {
          if (eventName == null) {
              return this._events.map((event) => event.listener);
          }
          let eventTag = getEventTag(eventName);
          return this._events
              .filter((event) => (event.tag === eventTag))
              .map((event) => event.listener);
      }
      off(eventName, listener) {
          if (listener == null) {
              return this.removeAllListeners(eventName);
          }
          const stopped = [];
          let found = false;
          let eventTag = getEventTag(eventName);
          this._events = this._events.filter((event) => {
              if (event.tag !== eventTag || event.listener != listener) {
                  return true;
              }
              if (found) {
                  return true;
              }
              found = true;
              stopped.push(event);
              return false;
          });
          stopped.forEach((event) => { this._stopEvent(event); });
          return this;
      }
      removeAllListeners(eventName) {
          let stopped = [];
          if (eventName == null) {
              stopped = this._events;
              this._events = [];
          }
          else {
              const eventTag = getEventTag(eventName);
              this._events = this._events.filter((event) => {
                  if (event.tag !== eventTag) {
                      return true;
                  }
                  stopped.push(event);
                  return false;
              });
          }
          stopped.forEach((event) => { this._stopEvent(event); });
          return this;
      }
  }
  //# sourceMappingURL=base-provider.js.map