conflux-web-net/dist/conflux-web-net.esm.js

import { formatters } from 'conflux-web-core-helpers';
import * as Utils from 'conflux-web-utils';
import { VersionMethod, GetBlockByNumberMethod, ListeningMethod, PeerCountMethod, AbstractMethodFactory } from 'conflux-web-core-method';
import { AbstractConfluxWebModule } from 'conflux-web-core';
import isFunction from 'lodash/isFunction';

function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
  try {
    var info = gen[key](arg);
    var value = info.value;
  } catch (error) {
    reject(error);
    return;
  }

  if (info.done) {
    resolve(value);
  } else {
    Promise.resolve(value).then(_next, _throw);
  }
}

function _asyncToGenerator(fn) {
  return function () {
    var self = this,
        args = arguments;
    return new Promise(function (resolve, reject) {
      var gen = fn.apply(self, args);

      function _next(value) {
        asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value);
      }

      function _throw(err) {
        asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err);
      }

      _next(undefined);
    });
  };
}

function _classCallCheck(instance, Constructor) {
  if (!(instance instanceof Constructor)) {
    throw new TypeError("Cannot call a class as a function");
  }
}

function _defineProperties(target, props) {
  for (var i = 0; i < props.length; i++) {
    var descriptor = props[i];
    descriptor.enumerable = descriptor.enumerable || false;
    descriptor.configurable = true;
    if ("value" in descriptor) descriptor.writable = true;
    Object.defineProperty(target, descriptor.key, descriptor);
  }
}

function _createClass(Constructor, protoProps, staticProps) {
  if (protoProps) _defineProperties(Constructor.prototype, protoProps);
  if (staticProps) _defineProperties(Constructor, staticProps);
  return Constructor;
}

function _inherits(subClass, superClass) {
  if (typeof superClass !== "function" && superClass !== null) {
    throw new TypeError("Super expression must either be null or a function");
  }

  subClass.prototype = Object.create(superClass && superClass.prototype, {
    constructor: {
      value: subClass,
      writable: true,
      configurable: true
    }
  });
  if (superClass) _setPrototypeOf(subClass, superClass);
}

function _getPrototypeOf(o) {
  _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) {
    return o.__proto__ || Object.getPrototypeOf(o);
  };
  return _getPrototypeOf(o);
}

function _setPrototypeOf(o, p) {
  _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) {
    o.__proto__ = p;
    return o;
  };

  return _setPrototypeOf(o, p);
}

function _isNativeReflectConstruct() {
  if (typeof Reflect === "undefined" || !Reflect.construct) return false;
  if (Reflect.construct.sham) return false;
  if (typeof Proxy === "function") return true;

  try {
    Date.prototype.toString.call(Reflect.construct(Date, [], function () {}));
    return true;
  } catch (e) {
    return false;
  }
}

function _assertThisInitialized(self) {
  if (self === void 0) {
    throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
  }

  return self;
}

function _possibleConstructorReturn(self, call) {
  if (call && (typeof call === "object" || typeof call === "function")) {
    return call;
  }

  return _assertThisInitialized(self);
}

function _createSuper(Derived) {
  return function () {
    var Super = _getPrototypeOf(Derived),
        result;

    if (_isNativeReflectConstruct()) {
      var NewTarget = _getPrototypeOf(this).constructor;

      result = Reflect.construct(Super, arguments, NewTarget);
    } else {
      result = Super.apply(this, arguments);
    }

    return _possibleConstructorReturn(this, result);
  };
}

var MethodFactory = function (_AbstractMethodFactor) {
  _inherits(MethodFactory, _AbstractMethodFactor);
  var _super = _createSuper(MethodFactory);
  function MethodFactory(utils, formatters) {
    var _this;
    _classCallCheck(this, MethodFactory);
    _this = _super.call(this, utils, formatters);
    _this.methods = {
      getId: VersionMethod,
      getBlockByNumber: GetBlockByNumberMethod,
      isListening: ListeningMethod,
      getPeerCount: PeerCountMethod
    };
    return _this;
  }
  return MethodFactory;
}(AbstractMethodFactory);

var Network = function (_AbstractConfluxWebMo) {
  _inherits(Network, _AbstractConfluxWebMo);
  var _super = _createSuper(Network);
  function Network(provider, methodFactory, utils, formatters, options, nodeNet) {
    var _this;
    _classCallCheck(this, Network);
    _this = _super.call(this, provider, options, methodFactory, nodeNet);
    _this.utils = utils;
    _this.formatters = formatters;
    return _this;
  }
  _createClass(Network, [{
    key: "getNetworkType",
    value: function () {
      var _getNetworkType = _asyncToGenerator( regeneratorRuntime.mark(function _callee(callback) {
        var id, networkType;
        return regeneratorRuntime.wrap(function _callee$(_context) {
          while (1) {
            switch (_context.prev = _context.next) {
              case 0:
                _context.prev = 0;
                _context.next = 3;
                return this.getId();
              case 3:
                id = _context.sent;
                networkType = 'private';
                _context.t0 = id;
                _context.next = _context.t0 === 1 ? 8 : _context.t0 === 2 ? 10 : _context.t0 === 3 ? 12 : _context.t0 === 4 ? 14 : _context.t0 === 42 ? 16 : 18;
                break;
              case 8:
                networkType = 'main';
                return _context.abrupt("break", 18);
              case 10:
                networkType = 'morden';
                return _context.abrupt("break", 18);
              case 12:
                networkType = 'ropsten';
                return _context.abrupt("break", 18);
              case 14:
                networkType = 'rinkeby';
                return _context.abrupt("break", 18);
              case 16:
                networkType = 'kovan';
                return _context.abrupt("break", 18);
              case 18:
                if (isFunction(callback)) {
                  callback(null, networkType);
                }
                return _context.abrupt("return", networkType);
              case 22:
                _context.prev = 22;
                _context.t1 = _context["catch"](0);
                if (isFunction(callback)) {
                  callback(_context.t1, null);
                }
                throw _context.t1;
              case 26:
              case "end":
                return _context.stop();
            }
          }
        }, _callee, this, [[0, 22]]);
      }));
      function getNetworkType(_x) {
        return _getNetworkType.apply(this, arguments);
      }
      return getNetworkType;
    }()
  }]);
  return Network;
}(AbstractConfluxWebModule);

function Network$1(provider) {
  var options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
  return new Network(provider, new MethodFactory(Utils, formatters), Utils, formatters, options, null);
}

export { Network$1 as Network };