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

'use strict';

Object.defineProperty(exports, '__esModule', { value: true });

function _interopDefault (ex) { return (ex && (typeof ex === 'object') && 'default' in ex) ? ex['default'] : ex; }

var confluxWebCoreHelpers = require('conflux-web-core-helpers');
var Utils = require('conflux-web-utils');
var _classCallCheck = _interopDefault(require('@babel/runtime/helpers/classCallCheck'));
var _possibleConstructorReturn = _interopDefault(require('@babel/runtime/helpers/possibleConstructorReturn'));
var _getPrototypeOf = _interopDefault(require('@babel/runtime/helpers/getPrototypeOf'));
var _inherits = _interopDefault(require('@babel/runtime/helpers/inherits'));
var confluxWebCoreMethod = require('conflux-web-core-method');
var _regeneratorRuntime = _interopDefault(require('@babel/runtime/regenerator'));
var _asyncToGenerator = _interopDefault(require('@babel/runtime/helpers/asyncToGenerator'));
var _createClass = _interopDefault(require('@babel/runtime/helpers/createClass'));
var confluxWebCore = require('conflux-web-core');
var isFunction = _interopDefault(require('lodash/isFunction'));

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); }; }
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; } }
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: confluxWebCoreMethod.VersionMethod,
      getBlockByNumber: confluxWebCoreMethod.GetBlockByNumberMethod,
      isListening: confluxWebCoreMethod.ListeningMethod,
      getPeerCount: confluxWebCoreMethod.PeerCountMethod
    };
    return _this;
  }
  return MethodFactory;
}(confluxWebCoreMethod.AbstractMethodFactory);

function _createSuper$1(Derived) { return function () { var Super = _getPrototypeOf(Derived), result; if (_isNativeReflectConstruct$1()) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
function _isNativeReflectConstruct$1() { 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; } }
var Network = function (_AbstractConfluxWebMo) {
  _inherits(Network, _AbstractConfluxWebMo);
  var _super = _createSuper$1(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;
}(confluxWebCore.AbstractConfluxWebModule);

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

exports.Network = Network$1;