conflux-web-core-method/dist/conflux-web-core-method.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 _classCallCheck = _interopDefault(require('@babel/runtime/helpers/classCallCheck'));
var _createClass = _interopDefault(require('@babel/runtime/helpers/createClass'));
var EventEmitter = _interopDefault(require('eventemitter3'));
var confluxWebCoreSubscriptions = require('conflux-web-core-subscriptions');
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 isFunction = _interopDefault(require('lodash/isFunction'));
var _toConsumableArray = _interopDefault(require('@babel/runtime/helpers/toConsumableArray'));
var _regeneratorRuntime = _interopDefault(require('@babel/runtime/regenerator'));
var _asyncToGenerator = _interopDefault(require('@babel/runtime/helpers/asyncToGenerator'));
var isString = _interopDefault(require('lodash/isString'));
var cloneDeep = _interopDefault(require('lodash/cloneDeep'));
var rxjs = require('rxjs');
var _get = _interopDefault(require('@babel/runtime/helpers/get'));

var PromiEvent = function () {
  function PromiEvent() {
    var _this = this;
    _classCallCheck(this, PromiEvent);
    this.promise = new Promise(function (resolve, reject) {
      _this.resolve = resolve;
      _this.reject = reject;
    });
    this.eventEmitter = new EventEmitter();
    return new Proxy(this, {
      get: this.proxyHandler
    });
  }
  _createClass(PromiEvent, [{
    key: "proxyHandler",
    value: function proxyHandler(target, name) {
      if (name === 'resolve' || name === 'reject') {
        return target[name];
      }
      if (name === 'then') {
        return target.promise.then.bind(target.promise);
      }
      if (name === 'catch') {
        return target.promise["catch"].bind(target.promise);
      }
      if (target.eventEmitter[name]) {
        return target.eventEmitter[name];
      }
    }
  }]);
  return PromiEvent;
}();

var AbstractMethod = function () {
  function AbstractMethod(rpcMethod, parametersAmount, utils, formatters, moduleInstance) {
    _classCallCheck(this, AbstractMethod);
    this.utils = utils;
    this.formatters = formatters;
    this.moduleInstance = moduleInstance;
    this._arguments = {
      parameters: []
    };
    this._rpcMethod = rpcMethod;
    this._parametersAmount = parametersAmount;
  }
  _createClass(AbstractMethod, [{
    key: "beforeExecution",
    value: function beforeExecution(moduleInstance) {}
  }, {
    key: "afterExecution",
    value: function afterExecution(response) {
      return response;
    }
  }, {
    key: "execute",
    value: function () {
      var _execute = _asyncToGenerator( _regeneratorRuntime.mark(function _callee() {
        var response;
        return _regeneratorRuntime.wrap(function _callee$(_context) {
          while (1) {
            switch (_context.prev = _context.next) {
              case 0:
                this.beforeExecution(this.moduleInstance);
                if (!(this.parameters.length !== this.parametersAmount)) {
                  _context.next = 3;
                  break;
                }
                throw new Error("Invalid Arguments length: expected: ".concat(this.parametersAmount, ", given: ").concat(this.parameters.length));
              case 3:
                _context.prev = 3;
                _context.next = 6;
                return this.moduleInstance.currentProvider.send(this.rpcMethod, this.parameters);
              case 6:
                response = _context.sent;
                if (response) {
                  response = this.afterExecution(response);
                }
                if (this.callback) {
                  this.callback(false, response);
                }
                return _context.abrupt("return", response);
              case 12:
                _context.prev = 12;
                _context.t0 = _context["catch"](3);
                if (this.callback) {
                  this.callback(_context.t0, null);
                }
                throw _context.t0;
              case 16:
              case "end":
                return _context.stop();
            }
          }
        }, _callee, this, [[3, 12]]);
      }));
      function execute() {
        return _execute.apply(this, arguments);
      }
      return execute;
    }()
  }, {
    key: "setArguments",
    value: function setArguments(methodArguments) {
      var parameters = cloneDeep(_toConsumableArray(methodArguments));
      var callback = null;
      if (parameters.length > this.parametersAmount) {
        if (!isFunction(parameters[parameters.length - 1])) {
          throw new TypeError("The latest parameter should be a function otherwise it can't be used as callback");
        }
        callback = parameters.pop();
      }
      this._arguments = {
        callback: callback,
        parameters: parameters
      };
    }
  }, {
    key: "getArguments",
    value: function getArguments() {
      return this._arguments;
    }
  }, {
    key: "isHash",
    value: function isHash(parameter) {
      return isString(parameter) && parameter.startsWith('0x');
    }
  }, {
    key: "rpcMethod",
    set: function set(value) {
      this._rpcMethod = value;
    }
    ,
    get: function get() {
      return this._rpcMethod;
    }
  }, {
    key: "parametersAmount",
    set: function set(value) {
      this._parametersAmount = value;
    }
    ,
    get: function get() {
      return this._parametersAmount;
    }
  }, {
    key: "parameters",
    get: function get() {
      return this._arguments.parameters;
    }
    ,
    set: function set(value) {
      this._arguments.parameters = value;
    }
  }, {
    key: "callback",
    get: function get() {
      return this._arguments.callback;
    }
    ,
    set: function set(value) {
      this._arguments.callback = value;
    }
  }]);
  return AbstractMethod;
}();

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 AbstractGetBlockMethod = function (_AbstractMethod) {
  _inherits(AbstractGetBlockMethod, _AbstractMethod);
  var _super = _createSuper(AbstractGetBlockMethod);
  function AbstractGetBlockMethod(rpcMethod, utils, formatters, moduleInstance) {
    _classCallCheck(this, AbstractGetBlockMethod);
    return _super.call(this, rpcMethod, 2, utils, formatters, moduleInstance);
  }
  _createClass(AbstractGetBlockMethod, [{
    key: "beforeExecution",
    value: function beforeExecution(moduleInstance) {
      this.parameters[0] = this.formatters.inputBlockAddressFormatter(this.parameters[0]);
      if (isFunction(this.parameters[1])) {
        this.callback = this.parameters[1];
        this.parameters[1] = false;
      } else {
        this.parameters[1] = !!this.parameters[1];
      }
    }
  }, {
    key: "afterExecution",
    value: function afterExecution(response) {
      return this.formatters.outputBlockFormatter(response);
    }
  }]);
  return AbstractGetBlockMethod;
}(AbstractMethod);

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 GetBlockByNumberMethod = function (_AbstractGetBlockMeth) {
  _inherits(GetBlockByNumberMethod, _AbstractGetBlockMeth);
  var _super = _createSuper$1(GetBlockByNumberMethod);
  function GetBlockByNumberMethod(utils, formatters, moduleInstance) {
    _classCallCheck(this, GetBlockByNumberMethod);
    return _super.call(this, 'cfx_getBlockByEpochNumber', utils, formatters, moduleInstance);
  }
  return GetBlockByNumberMethod;
}(AbstractGetBlockMethod);

function _createSuper$2(Derived) { return function () { var Super = _getPrototypeOf(Derived), result; if (_isNativeReflectConstruct$2()) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
function _isNativeReflectConstruct$2() { 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 GetTransactionReceiptMethod = function (_AbstractMethod) {
  _inherits(GetTransactionReceiptMethod, _AbstractMethod);
  var _super = _createSuper$2(GetTransactionReceiptMethod);
  function GetTransactionReceiptMethod(utils, formatters, moduleInstance) {
    _classCallCheck(this, GetTransactionReceiptMethod);
    return _super.call(this, 'cfx_getTransactionReceipt', 1, utils, formatters, moduleInstance);
  }
  _createClass(GetTransactionReceiptMethod, [{
    key: "afterExecution",
    value: function afterExecution(response) {
      if (response !== null) {
        return this.formatters.outputTransactionReceiptFormatter(response);
      }
      return response;
    }
  }]);
  return GetTransactionReceiptMethod;
}(AbstractMethod);

var TransactionObserver = function () {
  function TransactionObserver(provider, timeout, blockConfirmations, getTransactionReceiptMethod, getBlockByNumberMethod, newHeadsSubscription) {
    _classCallCheck(this, TransactionObserver);
    this.provider = provider;
    this.timeout = timeout;
    this.blockConfirmations = blockConfirmations;
    this.getTransactionReceiptMethod = getTransactionReceiptMethod;
    this.getBlockByNumberMethod = getBlockByNumberMethod;
    this.newHeadsSubscription = newHeadsSubscription;
    this.blockNumbers = [];
    this.lastBlock = false;
    this.confirmations = 0;
    this.confirmationChecks = 0;
    this.interval = false;
  }
  _createClass(TransactionObserver, [{
    key: "observe",
    value: function observe(transactionHash) {
      var _this = this;
      return rxjs.Observable.create(function (observer) {
        if (_this.provider.supportsSubscriptions()) {
          _this.startSocketObserver(transactionHash, observer);
        } else {
          _this.startHttpObserver(transactionHash, observer);
        }
      });
    }
  }, {
    key: "startSocketObserver",
    value: function startSocketObserver(transactionHash, observer) {
      var _this2 = this;
      this.newHeadsSubscription.subscribe( function () {
        var _ref = _asyncToGenerator( _regeneratorRuntime.mark(function _callee(error, newHead) {
          var receipt;
          return _regeneratorRuntime.wrap(function _callee$(_context) {
            while (1) {
              switch (_context.prev = _context.next) {
                case 0:
                  _context.prev = 0;
                  if (!observer.closed) {
                    _context.next = 5;
                    break;
                  }
                  _context.next = 4;
                  return _this2.newHeadsSubscription.unsubscribe();
                case 4:
                  return _context.abrupt("return");
                case 5:
                  if (!error) {
                    _context.next = 7;
                    break;
                  }
                  throw error;
                case 7:
                  _this2.getTransactionReceiptMethod.parameters = [transactionHash];
                  _context.next = 10;
                  return _this2.getTransactionReceiptMethod.execute();
                case 10:
                  receipt = _context.sent;
                  if (_this2.blockNumbers.includes(newHead.number)) {
                    _context.next = 25;
                    break;
                  }
                  if (!receipt) {
                    _context.next = 19;
                    break;
                  }
                  _this2.confirmations++;
                  _this2.emitNext(receipt, observer);
                  if (!_this2.isConfirmed()) {
                    _context.next = 19;
                    break;
                  }
                  _context.next = 18;
                  return _this2.newHeadsSubscription.unsubscribe();
                case 18:
                  observer.complete();
                case 19:
                  _this2.blockNumbers.push(newHead.number);
                  _this2.confirmationChecks++;
                  if (!_this2.isTimeoutTimeExceeded()) {
                    _context.next = 25;
                    break;
                  }
                  _context.next = 24;
                  return _this2.newHeadsSubscription.unsubscribe();
                case 24:
                  _this2.emitError(new Error('Timeout exceeded during the transaction confirmation process. Be aware the transaction could still get confirmed!'), receipt, observer);
                case 25:
                  _context.next = 30;
                  break;
                case 27:
                  _context.prev = 27;
                  _context.t0 = _context["catch"](0);
                  _this2.emitError(_context.t0, false, observer);
                case 30:
                case "end":
                  return _context.stop();
              }
            }
          }, _callee, null, [[0, 27]]);
        }));
        return function (_x, _x2) {
          return _ref.apply(this, arguments);
        };
      }());
    }
  }, {
    key: "startHttpObserver",
    value: function startHttpObserver(transactionHash, observer) {
      var _this3 = this;
      var interval = setInterval( _asyncToGenerator( _regeneratorRuntime.mark(function _callee2() {
        var receipt, block;
        return _regeneratorRuntime.wrap(function _callee2$(_context2) {
          while (1) {
            switch (_context2.prev = _context2.next) {
              case 0:
                _context2.prev = 0;
                if (!observer.closed) {
                  _context2.next = 4;
                  break;
                }
                clearInterval(interval);
                return _context2.abrupt("return");
              case 4:
                _this3.getTransactionReceiptMethod.parameters = [transactionHash];
                _context2.next = 7;
                return _this3.getTransactionReceiptMethod.execute();
              case 7:
                receipt = _context2.sent;
                if (!receipt) {
                  _context2.next = 22;
                  break;
                }
                if (!_this3.lastBlock) {
                  _context2.next = 16;
                  break;
                }
                _context2.next = 12;
                return _this3.getBlockByNumber(_this3.increaseBlockNumber(_this3.lastBlock.number));
              case 12:
                block = _context2.sent;
                if (block && _this3.isValidConfirmation(block)) {
                  _this3.lastBlock = block;
                  _this3.confirmations++;
                  _this3.emitNext(receipt, observer);
                }
                _context2.next = 21;
                break;
              case 16:
                _context2.next = 18;
                return _this3.getBlockByNumber(receipt.blockNumber);
              case 18:
                _this3.lastBlock = _context2.sent;
                _this3.confirmations++;
                _this3.emitNext(receipt, observer);
              case 21:
                if (_this3.isConfirmed()) {
                  clearInterval(interval);
                  observer.complete();
                }
              case 22:
                _this3.confirmationChecks++;
                if (_this3.isTimeoutTimeExceeded()) {
                  clearInterval(interval);
                  _this3.emitError(new Error('Timeout exceeded during the transaction confirmation process. Be aware the transaction could still get confirmed!'), receipt, observer);
                }
                _context2.next = 30;
                break;
              case 26:
                _context2.prev = 26;
                _context2.t0 = _context2["catch"](0);
                clearInterval(interval);
                _this3.emitError(_context2.t0, false, observer);
              case 30:
              case "end":
                return _context2.stop();
            }
          }
        }, _callee2, null, [[0, 26]]);
      })), 1000);
    }
  }, {
    key: "emitNext",
    value: function emitNext(receipt, observer) {
      observer.next({
        receipt: receipt,
        confirmations: this.confirmations
      });
    }
  }, {
    key: "emitError",
    value: function emitError(error, receipt, observer) {
      observer.error({
        error: error,
        receipt: receipt,
        confirmations: this.confirmations,
        confirmationChecks: this.confirmationChecks
      });
    }
  }, {
    key: "getBlockByNumber",
    value: function getBlockByNumber(blockNumber) {
      this.getBlockByNumberMethod.parameters = [blockNumber];
      return this.getBlockByNumberMethod.execute();
    }
  }, {
    key: "isConfirmed",
    value: function isConfirmed() {
      return this.confirmations === this.blockConfirmations;
    }
  }, {
    key: "isValidConfirmation",
    value: function isValidConfirmation(block) {
      return this.lastBlock.hash === block.parentHash && this.lastBlock.number !== block.number;
    }
  }, {
    key: "isTimeoutTimeExceeded",
    value: function isTimeoutTimeExceeded() {
      return this.confirmationChecks === this.timeout;
    }
  }, {
    key: "increaseBlockNumber",
    value: function increaseBlockNumber(blockNumber) {
      return '0x' + (parseInt(blockNumber, 16) + 1).toString(16);
    }
  }]);
  return TransactionObserver;
}();

function _createSuper$3(Derived) { return function () { var Super = _getPrototypeOf(Derived), result; if (_isNativeReflectConstruct$3()) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
function _isNativeReflectConstruct$3() { 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 GetTransactionCountMethod = function (_AbstractMethod) {
  _inherits(GetTransactionCountMethod, _AbstractMethod);
  var _super = _createSuper$3(GetTransactionCountMethod);
  function GetTransactionCountMethod(utils, formatters, moduleInstance) {
    _classCallCheck(this, GetTransactionCountMethod);
    return _super.call(this, 'cfx_getTransactionCount', 2, utils, formatters, moduleInstance);
  }
  _createClass(GetTransactionCountMethod, [{
    key: "beforeExecution",
    value: function beforeExecution(moduleInstance) {
      this.parameters[0] = this.formatters.inputAddressFormatter(this.parameters[0]);
      if (isFunction(this.parameters[1])) {
        this.callback = this.parameters[1];
        this.parameters[1] = moduleInstance.defaultEpoch;
      }
      this.parameters[1] = this.formatters.inputDefaultEpochNumberFormatter(this.parameters[1], moduleInstance);
    }
  }, {
    key: "afterExecution",
    value: function afterExecution(response) {
      return this.utils.hexToNumber(response);
    }
  }]);
  return GetTransactionCountMethod;
}(AbstractMethod);

function _createSuper$4(Derived) { return function () { var Super = _getPrototypeOf(Derived), result; if (_isNativeReflectConstruct$4()) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
function _isNativeReflectConstruct$4() { 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 ChainIdMethod = function (_AbstractMethod) {
  _inherits(ChainIdMethod, _AbstractMethod);
  var _super = _createSuper$4(ChainIdMethod);
  function ChainIdMethod(utils, formatters, moduleInstance) {
    _classCallCheck(this, ChainIdMethod);
    return _super.call(this, 'eth_chainId', 0, utils, formatters, moduleInstance);
  }
  _createClass(ChainIdMethod, [{
    key: "afterExecution",
    value: function afterExecution(response) {
      return this.utils.hexToNumber(response);
    }
  }]);
  return ChainIdMethod;
}(AbstractMethod);

var AbstractMethodFactory = function () {
  function AbstractMethodFactory(utils, formatters) {
    _classCallCheck(this, AbstractMethodFactory);
    this.utils = utils;
    this.formatters = formatters;
    this._methods = null;
  }
  _createClass(AbstractMethodFactory, [{
    key: "hasMethod",
    value: function hasMethod(name) {
      return typeof this.methods[name] !== 'undefined';
    }
  }, {
    key: "createMethod",
    value: function createMethod(name, moduleInstance) {
      var method = this.methods[name];
      if (method.Type === 'observed-transaction-method') {
        return new method(this.utils, this.formatters, moduleInstance, this.createTransactionObserver(moduleInstance));
      }
      if (method.Type === 'cfx-send-transaction-method') {
        return new method(this.utils, this.formatters, moduleInstance, this.createTransactionObserver(moduleInstance), new ChainIdMethod(this.utils, this.formatters, moduleInstance), new GetTransactionCountMethod(this.utils, this.formatters, moduleInstance));
      }
      return new method(this.utils, this.formatters, moduleInstance);
    }
  }, {
    key: "getTimeout",
    value: function getTimeout(moduleInstance) {
      var timeout = moduleInstance.transactionBlockTimeout;
      if (!moduleInstance.currentProvider.supportsSubscriptions()) {
        timeout = moduleInstance.transactionPollingTimeout;
      }
      return timeout;
    }
  }, {
    key: "createTransactionObserver",
    value: function createTransactionObserver(moduleInstance) {
      return new TransactionObserver(moduleInstance.currentProvider, this.getTimeout(moduleInstance), moduleInstance.transactionConfirmationBlocks, new GetTransactionReceiptMethod(this.utils, this.formatters, moduleInstance), new GetBlockByNumberMethod(this.utils, this.formatters, moduleInstance), new confluxWebCoreSubscriptions.NewHeadsSubscription(this.utils, this.formatters, moduleInstance));
    }
  }, {
    key: "methods",
    get: function get() {
      if (this._methods) {
        return this._methods;
      }
      throw new Error('No methods defined for MethodFactory!');
    }
    ,
    set: function set(value) {
      this._methods = value;
    }
  }]);
  return AbstractMethodFactory;
}();

var MethodProxy =
function MethodProxy(target, methodFactory) {
  _classCallCheck(this, MethodProxy);
  return new Proxy(target, {
    get: function get(target, name) {
      if (methodFactory.hasMethod(name)) {
        var RpcMethod = function RpcMethod() {
          method.setArguments(arguments);
          return method.execute();
        };
        if (typeof target[name] !== 'undefined') {
          throw new TypeError("Duplicated method ".concat(name, ". This method is defined as RPC call and as Object method."));
        }
        var method = methodFactory.createMethod(name, target);
        RpcMethod.method = method;
        RpcMethod.request = function () {
          method.setArguments(arguments);
          return method;
        };
        return RpcMethod;
      }
      return target[name];
    }
  });
};

function _createSuper$5(Derived) { return function () { var Super = _getPrototypeOf(Derived), result; if (_isNativeReflectConstruct$5()) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
function _isNativeReflectConstruct$5() { 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 GetProtocolVersionMethod = function (_AbstractMethod) {
  _inherits(GetProtocolVersionMethod, _AbstractMethod);
  var _super = _createSuper$5(GetProtocolVersionMethod);
  function GetProtocolVersionMethod(utils, formatters, moduleInstance) {
    _classCallCheck(this, GetProtocolVersionMethod);
    return _super.call(this, 'eth_protocolVersion', 0, utils, formatters, moduleInstance);
  }
  _createClass(GetProtocolVersionMethod, [{
    key: "afterExecution",
    value: function afterExecution(response) {
      return this.utils.hexToNumber(response);
    }
  }]);
  return GetProtocolVersionMethod;
}(AbstractMethod);

function _createSuper$6(Derived) { return function () { var Super = _getPrototypeOf(Derived), result; if (_isNativeReflectConstruct$6()) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
function _isNativeReflectConstruct$6() { 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 VersionMethod = function (_AbstractMethod) {
  _inherits(VersionMethod, _AbstractMethod);
  var _super = _createSuper$6(VersionMethod);
  function VersionMethod(utils, formatters, moduleInstance) {
    _classCallCheck(this, VersionMethod);
    return _super.call(this, 'net_version', 0, utils, formatters, moduleInstance);
  }
  _createClass(VersionMethod, [{
    key: "afterExecution",
    value: function afterExecution(response) {
      return this.utils.hexToNumber(response);
    }
  }]);
  return VersionMethod;
}(AbstractMethod);

function _createSuper$7(Derived) { return function () { var Super = _getPrototypeOf(Derived), result; if (_isNativeReflectConstruct$7()) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
function _isNativeReflectConstruct$7() { 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 ListeningMethod = function (_AbstractMethod) {
  _inherits(ListeningMethod, _AbstractMethod);
  var _super = _createSuper$7(ListeningMethod);
  function ListeningMethod(utils, formatters, moduleInstance) {
    _classCallCheck(this, ListeningMethod);
    return _super.call(this, 'net_listening', 0, utils, formatters, moduleInstance);
  }
  return ListeningMethod;
}(AbstractMethod);

function _createSuper$8(Derived) { return function () { var Super = _getPrototypeOf(Derived), result; if (_isNativeReflectConstruct$8()) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
function _isNativeReflectConstruct$8() { 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 PeerCountMethod = function (_AbstractMethod) {
  _inherits(PeerCountMethod, _AbstractMethod);
  var _super = _createSuper$8(PeerCountMethod);
  function PeerCountMethod(utils, formatters, moduleInstance) {
    _classCallCheck(this, PeerCountMethod);
    return _super.call(this, 'net_peerCount', 0, utils, formatters, moduleInstance);
  }
  _createClass(PeerCountMethod, [{
    key: "afterExecution",
    value: function afterExecution(response) {
      return this.utils.hexToNumber(response);
    }
  }]);
  return PeerCountMethod;
}(AbstractMethod);

function _createSuper$9(Derived) { return function () { var Super = _getPrototypeOf(Derived), result; if (_isNativeReflectConstruct$9()) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
function _isNativeReflectConstruct$9() { 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 GetNodeInfoMethod = function (_AbstractMethod) {
  _inherits(GetNodeInfoMethod, _AbstractMethod);
  var _super = _createSuper$9(GetNodeInfoMethod);
  function GetNodeInfoMethod(utils, formatters, moduleInstance) {
    _classCallCheck(this, GetNodeInfoMethod);
    return _super.call(this, 'confluxWeb_clientVersion', 0, utils, formatters, moduleInstance);
  }
  return GetNodeInfoMethod;
}(AbstractMethod);

function _createSuper$a(Derived) { return function () { var Super = _getPrototypeOf(Derived), result; if (_isNativeReflectConstruct$a()) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
function _isNativeReflectConstruct$a() { 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 GetCoinbaseMethod = function (_AbstractMethod) {
  _inherits(GetCoinbaseMethod, _AbstractMethod);
  var _super = _createSuper$a(GetCoinbaseMethod);
  function GetCoinbaseMethod(utils, formatters, moduleInstance) {
    _classCallCheck(this, GetCoinbaseMethod);
    return _super.call(this, 'eth_coinbase', 0, utils, formatters, moduleInstance);
  }
  return GetCoinbaseMethod;
}(AbstractMethod);

function _createSuper$b(Derived) { return function () { var Super = _getPrototypeOf(Derived), result; if (_isNativeReflectConstruct$b()) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
function _isNativeReflectConstruct$b() { 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 IsMiningMethod = function (_AbstractMethod) {
  _inherits(IsMiningMethod, _AbstractMethod);
  var _super = _createSuper$b(IsMiningMethod);
  function IsMiningMethod(utils, formatters, moduleInstance) {
    _classCallCheck(this, IsMiningMethod);
    return _super.call(this, 'eth_mining', 0, utils, formatters, moduleInstance);
  }
  return IsMiningMethod;
}(AbstractMethod);

function _createSuper$c(Derived) { return function () { var Super = _getPrototypeOf(Derived), result; if (_isNativeReflectConstruct$c()) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
function _isNativeReflectConstruct$c() { 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 GetHashrateMethod = function (_AbstractMethod) {
  _inherits(GetHashrateMethod, _AbstractMethod);
  var _super = _createSuper$c(GetHashrateMethod);
  function GetHashrateMethod(utils, formatters, moduleInstance) {
    _classCallCheck(this, GetHashrateMethod);
    return _super.call(this, 'eth_hashrate', 0, utils, formatters, moduleInstance);
  }
  _createClass(GetHashrateMethod, [{
    key: "afterExecution",
    value: function afterExecution(response) {
      return this.utils.hexToNumber(response);
    }
  }]);
  return GetHashrateMethod;
}(AbstractMethod);

function _createSuper$d(Derived) { return function () { var Super = _getPrototypeOf(Derived), result; if (_isNativeReflectConstruct$d()) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
function _isNativeReflectConstruct$d() { 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 IsSyncingMethod = function (_AbstractMethod) {
  _inherits(IsSyncingMethod, _AbstractMethod);
  var _super = _createSuper$d(IsSyncingMethod);
  function IsSyncingMethod(utils, formatters, moduleInstance) {
    _classCallCheck(this, IsSyncingMethod);
    return _super.call(this, 'eth_syncing', 0, utils, formatters, moduleInstance);
  }
  _createClass(IsSyncingMethod, [{
    key: "afterExecution",
    value: function afterExecution(response) {
      if (typeof response !== 'boolean') {
        return this.formatters.outputSyncingFormatter(response);
      }
      return response;
    }
  }]);
  return IsSyncingMethod;
}(AbstractMethod);

function _createSuper$e(Derived) { return function () { var Super = _getPrototypeOf(Derived), result; if (_isNativeReflectConstruct$e()) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
function _isNativeReflectConstruct$e() { 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 GetGasPriceMethod = function (_AbstractMethod) {
  _inherits(GetGasPriceMethod, _AbstractMethod);
  var _super = _createSuper$e(GetGasPriceMethod);
  function GetGasPriceMethod(utils, formatters, moduleInstance) {
    _classCallCheck(this, GetGasPriceMethod);
    return _super.call(this, 'cfx_gasPrice', 0, utils, formatters, moduleInstance);
  }
  _createClass(GetGasPriceMethod, [{
    key: "afterExecution",
    value: function afterExecution(response) {
      return this.formatters.outputBigNumberFormatter(response);
    }
  }]);
  return GetGasPriceMethod;
}(AbstractMethod);

function _createSuper$f(Derived) { return function () { var Super = _getPrototypeOf(Derived), result; if (_isNativeReflectConstruct$f()) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
function _isNativeReflectConstruct$f() { 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 SubmitWorkMethod = function (_AbstractMethod) {
  _inherits(SubmitWorkMethod, _AbstractMethod);
  var _super = _createSuper$f(SubmitWorkMethod);
  function SubmitWorkMethod(utils, formatters, moduleInstance) {
    _classCallCheck(this, SubmitWorkMethod);
    return _super.call(this, 'eth_submitWork', 3, utils, formatters, moduleInstance);
  }
  return SubmitWorkMethod;
}(AbstractMethod);

function _createSuper$g(Derived) { return function () { var Super = _getPrototypeOf(Derived), result; if (_isNativeReflectConstruct$g()) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
function _isNativeReflectConstruct$g() { 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 GetWorkMethod = function (_AbstractMethod) {
  _inherits(GetWorkMethod, _AbstractMethod);
  var _super = _createSuper$g(GetWorkMethod);
  function GetWorkMethod(utils, formatters, moduleInstance) {
    _classCallCheck(this, GetWorkMethod);
    return _super.call(this, 'eth_getWork', 0, utils, formatters, moduleInstance);
  }
  return GetWorkMethod;
}(AbstractMethod);

function _createSuper$h(Derived) { return function () { var Super = _getPrototypeOf(Derived), result; if (_isNativeReflectConstruct$h()) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
function _isNativeReflectConstruct$h() { 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 GetAccountsMethod = function (_AbstractMethod) {
  _inherits(GetAccountsMethod, _AbstractMethod);
  var _super = _createSuper$h(GetAccountsMethod);
  function GetAccountsMethod(utils, formatters, moduleInstance) {
    _classCallCheck(this, GetAccountsMethod);
    return _super.call(this, 'cfx_accounts', 0, utils, formatters, moduleInstance);
  }
  _createClass(GetAccountsMethod, [{
    key: "afterExecution",
    value: function afterExecution(response) {
      var _this = this;
      return response.map(function (responseItem) {
        return _this.utils.toChecksumAddress(responseItem);
      });
    }
  }]);
  return GetAccountsMethod;
}(AbstractMethod);

function _createSuper$i(Derived) { return function () { var Super = _getPrototypeOf(Derived), result; if (_isNativeReflectConstruct$i()) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
function _isNativeReflectConstruct$i() { 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 GetBalanceMethod = function (_AbstractMethod) {
  _inherits(GetBalanceMethod, _AbstractMethod);
  var _super = _createSuper$i(GetBalanceMethod);
  function GetBalanceMethod(utils, formatters, moduleInstance) {
    _classCallCheck(this, GetBalanceMethod);
    return _super.call(this, 'cfx_getBalance', 2, utils, formatters, moduleInstance);
  }
  _createClass(GetBalanceMethod, [{
    key: "beforeExecution",
    value: function beforeExecution(moduleInstance) {
      this.parameters[0] = this.formatters.inputAddressFormatter(this.parameters[0]);
      if (isFunction(this.parameters[1])) {
        this.callback = this.parameters[1];
        this.parameters[1] = moduleInstance.defaultEpoch;
      }
      this.parameters[1] = this.formatters.inputDefaultEpochNumberFormatter(this.parameters[1], moduleInstance);
    }
  }, {
    key: "afterExecution",
    value: function afterExecution(response) {
      return this.formatters.outputBigNumberFormatter(response);
    }
  }]);
  return GetBalanceMethod;
}(AbstractMethod);

function _createSuper$j(Derived) { return function () { var Super = _getPrototypeOf(Derived), result; if (_isNativeReflectConstruct$j()) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
function _isNativeReflectConstruct$j() { 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 RequestAccountsMethod = function (_AbstractMethod) {
  _inherits(RequestAccountsMethod, _AbstractMethod);
  var _super = _createSuper$j(RequestAccountsMethod);
  function RequestAccountsMethod(utils, formatters, moduleInstance) {
    _classCallCheck(this, RequestAccountsMethod);
    return _super.call(this, 'eth_requestAccounts', 0, utils, formatters, moduleInstance);
  }
  return RequestAccountsMethod;
}(AbstractMethod);

function _createSuper$k(Derived) { return function () { var Super = _getPrototypeOf(Derived), result; if (_isNativeReflectConstruct$k()) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
function _isNativeReflectConstruct$k() { 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 AbstractGetBlockTransactionCountMethod = function (_AbstractMethod) {
  _inherits(AbstractGetBlockTransactionCountMethod, _AbstractMethod);
  var _super = _createSuper$k(AbstractGetBlockTransactionCountMethod);
  function AbstractGetBlockTransactionCountMethod(rpcMethod, utils, formatters, moduleInstance) {
    _classCallCheck(this, AbstractGetBlockTransactionCountMethod);
    return _super.call(this, rpcMethod, 1, utils, formatters, moduleInstance);
  }
  _createClass(AbstractGetBlockTransactionCountMethod, [{
    key: "beforeExecution",
    value: function beforeExecution(moduleInstance) {
      this.parameters[0] = this.formatters.inputBlockAddressFormatter(this.parameters[0]);
    }
  }, {
    key: "afterExecution",
    value: function afterExecution(response) {
      return this.utils.hexToNumber(response);
    }
  }]);
  return AbstractGetBlockTransactionCountMethod;
}(AbstractMethod);

function _createSuper$l(Derived) { return function () { var Super = _getPrototypeOf(Derived), result; if (_isNativeReflectConstruct$l()) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
function _isNativeReflectConstruct$l() { 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 GetBlockByHashMethod = function (_AbstractGetBlockMeth) {
  _inherits(GetBlockByHashMethod, _AbstractGetBlockMeth);
  var _super = _createSuper$l(GetBlockByHashMethod);
  function GetBlockByHashMethod(utils, formatters, moduleInstance) {
    _classCallCheck(this, GetBlockByHashMethod);
    return _super.call(this, 'cfx_getBlockByHash', utils, formatters, moduleInstance);
  }
  return GetBlockByHashMethod;
}(AbstractGetBlockMethod);

function _createSuper$m(Derived) { return function () { var Super = _getPrototypeOf(Derived), result; if (_isNativeReflectConstruct$m()) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
function _isNativeReflectConstruct$m() { 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 GetBlockTransactionCountByHashMethod = function (_AbstractGetBlockTran) {
  _inherits(GetBlockTransactionCountByHashMethod, _AbstractGetBlockTran);
  var _super = _createSuper$m(GetBlockTransactionCountByHashMethod);
  function GetBlockTransactionCountByHashMethod(utils, formatters, moduleInstance) {
    _classCallCheck(this, GetBlockTransactionCountByHashMethod);
    return _super.call(this, 'cfx_getBlockTransactionCountByHash', utils, formatters, moduleInstance);
  }
  return GetBlockTransactionCountByHashMethod;
}(AbstractGetBlockTransactionCountMethod);

function _createSuper$n(Derived) { return function () { var Super = _getPrototypeOf(Derived), result; if (_isNativeReflectConstruct$n()) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
function _isNativeReflectConstruct$n() { 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 GetBlockTransactionCountByNumberMethod = function (_AbstractGetBlockTran) {
  _inherits(GetBlockTransactionCountByNumberMethod, _AbstractGetBlockTran);
  var _super = _createSuper$n(GetBlockTransactionCountByNumberMethod);
  function GetBlockTransactionCountByNumberMethod(utils, formatters, moduleInstance) {
    _classCallCheck(this, GetBlockTransactionCountByNumberMethod);
    return _super.call(this, 'cfx_getBlockTransactionCountByNumber', utils, formatters, moduleInstance);
  }
  return GetBlockTransactionCountByNumberMethod;
}(AbstractGetBlockTransactionCountMethod);

function _createSuper$o(Derived) { return function () { var Super = _getPrototypeOf(Derived), result; if (_isNativeReflectConstruct$o()) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
function _isNativeReflectConstruct$o() { 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 AbstractGetTransactionFromBlockMethod = function (_AbstractMethod) {
  _inherits(AbstractGetTransactionFromBlockMethod, _AbstractMethod);
  var _super = _createSuper$o(AbstractGetTransactionFromBlockMethod);
  function AbstractGetTransactionFromBlockMethod(rpcMethod, utils, formatters, moduleInstance) {
    _classCallCheck(this, AbstractGetTransactionFromBlockMethod);
    return _super.call(this, rpcMethod, 2, utils, formatters, moduleInstance);
  }
  _createClass(AbstractGetTransactionFromBlockMethod, [{
    key: "beforeExecution",
    value: function beforeExecution(moduleInstance) {
      this.parameters[0] = this.formatters.inputBlockAddressFormatter(this.parameters[0]);
      this.parameters[1] = this.utils.numberToHex(this.parameters[1]);
    }
  }, {
    key: "afterExecution",
    value: function afterExecution(response) {
      return this.formatters.outputTransactionFormatter(response);
    }
  }]);
  return AbstractGetTransactionFromBlockMethod;
}(AbstractMethod);

function _createSuper$p(Derived) { return function () { var Super = _getPrototypeOf(Derived), result; if (_isNativeReflectConstruct$p()) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
function _isNativeReflectConstruct$p() { 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 AbstractObservedTransactionMethod = function (_AbstractMethod) {
  _inherits(AbstractObservedTransactionMethod, _AbstractMethod);
  var _super = _createSuper$p(AbstractObservedTransactionMethod);
  function AbstractObservedTransactionMethod(rpcMethod, parametersAmount, utils, formatters, moduleInstance, transactionObserver) {
    var _this;
    _classCallCheck(this, AbstractObservedTransactionMethod);
    _this = _super.call(this, rpcMethod, parametersAmount, utils, formatters, moduleInstance);
    _this.transactionObserver = transactionObserver;
    _this.promiEvent = new PromiEvent();
    return _this;
  }
  _createClass(AbstractObservedTransactionMethod, [{
    key: "execute",
    value: function execute() {
      var _this2 = this;
      this.beforeExecution(this.moduleInstance);
      this.moduleInstance.currentProvider.send(this.rpcMethod, this.parameters).then(function (transactionHash) {
        if (_this2.callback) {
          _this2.promiEvent.resolve(_this2.callback(false, transactionHash));
          return;
        }
        _this2.promiEvent.resolve(transactionHash);
      })["catch"](function (error) {
        if (_this2.callback) {
          _this2.callback(error, null);
          return;
        }
        _this2.handleError(error, false, 0);
      });
      return this.promiEvent;
    }
  }, {
    key: "handleError",
    value: function handleError(error, receipt, confirmations) {
      if (this.promiEvent.listenerCount('error') > 0) {
        this.promiEvent.emit('error', error, receipt, confirmations);
        this.promiEvent.removeAllListeners();
        return;
      }
      this.promiEvent.reject(error);
    }
  }], [{
    key: "Type",
    get: function get() {
      return 'observed-transaction-method';
    }
  }]);
  return AbstractObservedTransactionMethod;
}(AbstractMethod);

function _createSuper$q(Derived) { return function () { var Super = _getPrototypeOf(Derived), result; if (_isNativeReflectConstruct$q()) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
function _isNativeReflectConstruct$q() { 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 SendTransactionMethod = function (_AbstractObservedTran) {
  _inherits(SendTransactionMethod, _AbstractObservedTran);
  var _super = _createSuper$q(SendTransactionMethod);
  function SendTransactionMethod(utils, formatters, moduleInstance, transactionObserver) {
    _classCallCheck(this, SendTransactionMethod);
    return _super.call(this, 'cfx_sendTransaction', 1, utils, formatters, moduleInstance, transactionObserver);
  }
  _createClass(SendTransactionMethod, [{
    key: "beforeExecution",
    value: function beforeExecution(moduleInstance) {
      this.parameters[0] = this.formatters.inputTransactionFormatter(this.parameters[0], moduleInstance);
    }
  }]);
  return SendTransactionMethod;
}(AbstractObservedTransactionMethod);

function _createSuper$r(Derived) { return function () { var Super = _getPrototypeOf(Derived), result; if (_isNativeReflectConstruct$r()) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
function _isNativeReflectConstruct$r() { 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 CfxSendTransactionMethod = function (_SendTransactionMetho) {
  _inherits(CfxSendTransactionMethod, _SendTransactionMetho);
  var _super = _createSuper$r(CfxSendTransactionMethod);
  function CfxSendTransactionMethod(utils, formatters, moduleInstance, transactionObserver, chainIdMethod, getTransactionCountMethod) {
    var _this;
    _classCallCheck(this, CfxSendTransactionMethod);
    _this = _super.call(this, utils, formatters, moduleInstance, transactionObserver);
    _this.chainIdMethod = chainIdMethod;
    _this.getTransactionCountMethod = getTransactionCountMethod;
    return _this;
  }
  _createClass(CfxSendTransactionMethod, [{
    key: "beforeExecution",
    value: function beforeExecution(moduleInstance) {
      if (this.rpcMethod !== 'cfx_sendRawTransaction') {
        _get(_getPrototypeOf(CfxSendTransactionMethod.prototype), "beforeExecution", this).call(this, moduleInstance);
      }
    }
  }, {
    key: "execute",
    value: function execute() {
      var _this2 = this;
      if (!this.parameters[0].gas && this.moduleInstance.defaultGas) {
        this.parameters[0]['gas'] = this.moduleInstance.defaultGas;
      }
      if (!this.parameters[0].gasPrice && this.parameters[0].gasPrice !== 0) {
        if (!this.moduleInstance.defaultGasPrice) {
          this.moduleInstance.currentProvider.send('cfx_gasPrice', []).then(function (gasPrice) {
            _this2.parameters[0].gasPrice = gasPrice;
            _this2.execute();
          })["catch"](function (error) {
            _this2.handleError(error, false, 0);
          });
          return this.promiEvent;
        }
        this.parameters[0]['gasPrice'] = this.moduleInstance.defaultGasPrice;
      }
      if (this.hasAccounts() && this.isDefaultSigner()) {
        if (this.moduleInstance.accounts.wallet[this.parameters[0].from]) {
          this.sendRawTransaction(this.moduleInstance.accounts.wallet[this.parameters[0].from].privateKey)["catch"](function (error) {
            _this2.handleError(error, false, 0);
          });
          return this.promiEvent;
        }
      }
      if (this.hasCustomSigner()) {
        this.sendRawTransaction()["catch"](function (error) {
          _this2.handleError(error, false, 0);
        });
        return this.promiEvent;
      }
      return _get(_getPrototypeOf(CfxSendTransactionMethod.prototype), "execute", this).call(this);
    }
  }, {
    key: "sendRawTransaction",
    value: function () {
      var _sendRawTransaction = _asyncToGenerator( _regeneratorRuntime.mark(function _callee() {
        var privateKey,
            transaction,
            response,
            _args = arguments;
        return _regeneratorRuntime.wrap(function _callee$(_context) {
          while (1) {
            switch (_context.prev = _context.next) {
              case 0:
                privateKey = _args.length > 0 && _args[0] !== undefined ? _args[0] : null;
                this.beforeExecution(this.moduleInstance);
                if (!(!this.parameters[0].nonce && this.parameters[0].nonce !== 0)) {
                  _context.next = 7;
                  break;
                }
                this.getTransactionCountMethod.parameters = [this.parameters[0].from, 'latest_state'];
                _context.next = 6;
                return this.getTransactionCountMethod.execute();
              case 6:
                this.parameters[0].nonce = _context.sent;
              case 7:
                if (!this.parameters[0].storageLimit) {
                  this.parameters[0]['storageLimit'] = 100000000;
                }
                if (!this.parameters[0].chainId) {
                  this.parameters[0]['chainId'] = 0;
                }
                if (this.parameters[0].epochHeight) {
                  _context.next = 13;
                  break;
                }
                _context.next = 12;
                return this.moduleInstance.currentProvider.send('cfx_epochNumber', []);
              case 12:
                this.parameters[0].epochHeight = _context.sent;
              case 13:
                transaction = this.parameters[0];
                transaction.to = transaction.to || '0x';
                transaction.data = transaction.data || '0x';
                transaction.value = transaction.value || '0x';
                delete transaction.from;
                _context.next = 20;
                return this.moduleInstance.transactionSigner.sign(transaction, privateKey);
              case 20:
                response = _context.sent;
                this.parameters = [response.rawTransaction];
                this.rpcMethod = 'cfx_sendRawTransaction';
                return _context.abrupt("return", _get(_getPrototypeOf(CfxSendTransactionMethod.prototype), "execute", this).call(this));
              case 24:
              case "end":
                return _context.stop();
            }
          }
        }, _callee, this);
      }));
      function sendRawTransaction() {
        return _sendRawTransaction.apply(this, arguments);
      }
      return sendRawTransaction;
    }()
  }, {
    key: "isDefaultSigner",
    value: function isDefaultSigner() {
      return this.moduleInstance.transactionSigner.type === 'TransactionSigner';
    }
  }, {
    key: "hasAccounts",
    value: function hasAccounts() {
      return this.moduleInstance.accounts && this.moduleInstance.accounts.wallet.accountsIndex > 0;
    }
  }, {
    key: "hasCustomSigner",
    value: function hasCustomSigner() {
      return this.moduleInstance.transactionSigner.type !== 'TransactionSigner';
    }
  }], [{
    key: "Type",
    get: function get() {
      return 'cfx-send-transaction-method';
    }
  }]);
  return CfxSendTransactionMethod;
}(SendTransactionMethod);

function _createSuper$s(Derived) { return function () { var Super = _getPrototypeOf(Derived), result; if (_isNativeReflectConstruct$s()) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
function _isNativeReflectConstruct$s() { 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 GetTransactionMethod = function (_AbstractMethod) {
  _inherits(GetTransactionMethod, _AbstractMethod);
  var _super = _createSuper$s(GetTransactionMethod);
  function GetTransactionMethod(utils, formatters, moduleInstance) {
    _classCallCheck(this, GetTransactionMethod);
    return _super.call(this, 'cfx_getTransactionByHash', 1, utils, formatters, moduleInstance);
  }
  _createClass(GetTransactionMethod, [{
    key: "afterExecution",
    value: function afterExecution(response) {
      return this.formatters.outputTransactionFormatter(response);
    }
  }]);
  return GetTransactionMethod;
}(AbstractMethod);

function _createSuper$t(Derived) { return function () { var Super = _getPrototypeOf(Derived), result; if (_isNativeReflectConstruct$t()) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
function _isNativeReflectConstruct$t() { 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 GetTransactionByBlockHashAndIndexMethod = function (_AbstractGetTransacti) {
  _inherits(GetTransactionByBlockHashAndIndexMethod, _AbstractGetTransacti);
  var _super = _createSuper$t(GetTransactionByBlockHashAndIndexMethod);
  function GetTransactionByBlockHashAndIndexMethod(utils, formatters, moduleInstance) {
    _classCallCheck(this, GetTransactionByBlockHashAndIndexMethod);
    return _super.call(this, 'cfx_getTransactionByBlockHashAndIndex', utils, formatters, moduleInstance);
  }
  return GetTransactionByBlockHashAndIndexMethod;
}(AbstractGetTransactionFromBlockMethod);

function _createSuper$u(Derived) { return function () { var Super = _getPrototypeOf(Derived), result; if (_isNativeReflectConstruct$u()) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
function _isNativeReflectConstruct$u() { 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 GetTransactionByBlockAddressAndIndexMethod = function (_AbstractGetTransacti) {
  _inherits(GetTransactionByBlockAddressAndIndexMethod, _AbstractGetTransacti);
  var _super = _createSuper$u(GetTransactionByBlockAddressAndIndexMethod);
  function GetTransactionByBlockAddressAndIndexMethod(utils, formatters, moduleInstance) {
    _classCallCheck(this, GetTransactionByBlockAddressAndIndexMethod);
    return _super.call(this, 'cfx_getTransactionByBlockAddressAndIndex', utils, formatters, moduleInstance);
  }
  return GetTransactionByBlockAddressAndIndexMethod;
}(AbstractGetTransactionFromBlockMethod);

function _createSuper$v(Derived) { return function () { var Super = _getPrototypeOf(Derived), result; if (_isNativeReflectConstruct$v()) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
function _isNativeReflectConstruct$v() { 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 SendRawTransactionMethod = function (_AbstractObservedTran) {
  _inherits(SendRawTransactionMethod, _AbstractObservedTran);
  var _super = _createSuper$v(SendRawTransactionMethod);
  function SendRawTransactionMethod(utils, formatters, moduleInstance, transactionObserver) {
    _classCallCheck(this, SendRawTransactionMethod);
    return _super.call(this, 'cfx_sendRawTransaction', 1, utils, formatters, moduleInstance, transactionObserver);
  }
  return SendRawTransactionMethod;
}(AbstractObservedTransactionMethod);

function _createSuper$w(Derived) { return function () { var Super = _getPrototypeOf(Derived), result; if (_isNativeReflectConstruct$w()) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
function _isNativeReflectConstruct$w() { 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 SignTransactionMethod = function (_AbstractMethod) {
  _inherits(SignTransactionMethod, _AbstractMethod);
  var _super = _createSuper$w(SignTransactionMethod);
  function SignTransactionMethod(utils, formatters, moduleInstance) {
    _classCallCheck(this, SignTransactionMethod);
    return _super.call(this, 'cfx_signTransaction', 1, utils, formatters, moduleInstance);
  }
  _createClass(SignTransactionMethod, [{
    key: "beforeExecution",
    value: function beforeExecution(moduleInstance) {
      this.parameters[0] = this.formatters.inputTransactionFormatter(this.parameters[0], moduleInstance);
    }
  }]);
  return SignTransactionMethod;
}(AbstractMethod);

function _createSuper$x(Derived) { return function () { var Super = _getPrototypeOf(Derived), result; if (_isNativeReflectConstruct$x()) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
function _isNativeReflectConstruct$x() { 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 GetCodeMethod = function (_AbstractMethod) {
  _inherits(GetCodeMethod, _AbstractMethod);
  var _super = _createSuper$x(GetCodeMethod);
  function GetCodeMethod(utils, formatters, moduleInstance) {
    _classCallCheck(this, GetCodeMethod);
    return _super.call(this, 'cfx_getCode', 2, utils, formatters, moduleInstance);
  }
  _createClass(GetCodeMethod, [{
    key: "beforeExecution",
    value: function beforeExecution(moduleInstance) {
      this.parameters[0] = this.formatters.inputAddressFormatter(this.parameters[0]);
      if (isFunction(this.parameters[1])) {
        this.callback = this.parameters[1];
        this.parameters[1] = moduleInstance.defaultEpoch;
      }
      this.parameters[1] = this.formatters.inputDefaultEpochNumberFormatter(this.parameters[1], moduleInstance);
    }
  }]);
  return GetCodeMethod;
}(AbstractMethod);

function _createSuper$y(Derived) { return function () { var Super = _getPrototypeOf(Derived), result; if (_isNativeReflectConstruct$y()) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
function _isNativeReflectConstruct$y() { 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 SignMethod = function (_AbstractMethod) {
  _inherits(SignMethod, _AbstractMethod);
  var _super = _createSuper$y(SignMethod);
  function SignMethod(utils, formatters, moduleInstance) {
    _classCallCheck(this, SignMethod);
    return _super.call(this, 'cfx_sign', 2, utils, formatters, moduleInstance);
  }
  _createClass(SignMethod, [{
    key: "beforeExecution",
    value: function beforeExecution(moduleInstance) {
      this.parameters[0] = this.formatters.inputSignFormatter(this.parameters[0]);
      this.parameters[1] = this.formatters.inputAddressFormatter(this.parameters[1]);
      this.parameters.reverse();
    }
  }]);
  return SignMethod;
}(AbstractMethod);

function _createSuper$z(Derived) { return function () { var Super = _getPrototypeOf(Derived), result; if (_isNativeReflectConstruct$z()) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
function _isNativeReflectConstruct$z() { 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 CallMethod = function (_AbstractMethod) {
  _inherits(CallMethod, _AbstractMethod);
  var _super = _createSuper$z(CallMethod);
  function CallMethod(utils, formatters, moduleInstance) {
    _classCallCheck(this, CallMethod);
    return _super.call(this, 'cfx_call', 2, utils, formatters, moduleInstance);
  }
  _createClass(CallMethod, [{
    key: "beforeExecution",
    value: function beforeExecution(moduleInstance) {
      this.parameters[0] = this.formatters.inputCallFormatter(this.parameters[0], moduleInstance);
      if (isFunction(this.parameters[1])) {
        this.callback = this.parameters[1];
        this.parameters[1] = moduleInstance.defaultEpoch;
      }
      this.parameters[1] = this.formatters.inputDefaultEpochNumberFormatter(this.parameters[1], moduleInstance);
    }
  }]);
  return CallMethod;
}(AbstractMethod);

function _createSuper$A(Derived) { return function () { var Super = _getPrototypeOf(Derived), result; if (_isNativeReflectConstruct$A()) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
function _isNativeReflectConstruct$A() { 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 GetStorageAtMethod = function (_AbstractMethod) {
  _inherits(GetStorageAtMethod, _AbstractMethod);
  var _super = _createSuper$A(GetStorageAtMethod);
  function GetStorageAtMethod(utils, formatters, moduleInstance) {
    _classCallCheck(this, GetStorageAtMethod);
    return _super.call(this, 'eth_getStorageAt', 3, utils, formatters, moduleInstance);
  }
  _createClass(GetStorageAtMethod, [{
    key: "beforeExecution",
    value: function beforeExecution(moduleInstance) {
      this.parameters[0] = this.formatters.inputAddressFormatter(this.parameters[0]);
      this.parameters[1] = this.utils.numberToHex(this.parameters[1]);
      if (isFunction(this.parameters[2])) {
        this.callback = this.parameters[2];
        this.parameters[2] = moduleInstance.defaultEpoch;
      }
      this.parameters[2] = this.formatters.inputDefaultEpochNumberFormatter(this.parameters[2], moduleInstance);
    }
  }]);
  return GetStorageAtMethod;
}(AbstractMethod);

function _createSuper$B(Derived) { return function () { var Super = _getPrototypeOf(Derived), result; if (_isNativeReflectConstruct$B()) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
function _isNativeReflectConstruct$B() { 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 EstimateGasMethod = function (_AbstractMethod) {
  _inherits(EstimateGasMethod, _AbstractMethod);
  var _super = _createSuper$B(EstimateGasMethod);
  function EstimateGasMethod(utils, formatters, moduleInstance) {
    _classCallCheck(this, EstimateGasMethod);
    return _super.call(this, 'cfx_estimateGas', 1, utils, formatters, moduleInstance);
  }
  _createClass(EstimateGasMethod, [{
    key: "beforeExecution",
    value: function beforeExecution(moduleInstance) {
      this.parameters[0] = this.formatters.inputCallFormatter(this.parameters[0], moduleInstance);
    }
  }, {
    key: "afterExecution",
    value: function afterExecution(response) {
      return this.utils.hexToNumber(response);
    }
  }]);
  return EstimateGasMethod;
}(AbstractMethod);

function _createSuper$C(Derived) { return function () { var Super = _getPrototypeOf(Derived), result; if (_isNativeReflectConstruct$C()) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
function _isNativeReflectConstruct$C() { 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 GetPastLogsMethod = function (_AbstractMethod) {
  _inherits(GetPastLogsMethod, _AbstractMethod);
  var _super = _createSuper$C(GetPastLogsMethod);
  function GetPastLogsMethod(utils, formatters, moduleInstance) {
    _classCallCheck(this, GetPastLogsMethod);
    return _super.call(this, 'cfx_getLogs', 1, utils, formatters, moduleInstance);
  }
  _createClass(GetPastLogsMethod, [{
    key: "beforeExecution",
    value: function beforeExecution(moduleInstance) {
      this.parameters[0] = this.formatters.inputLogFormatter(this.parameters[0]);
    }
  }, {
    key: "afterExecution",
    value: function afterExecution(response) {
      var _this = this;
      return response.map(function (responseItem) {
        return _this.formatters.outputLogFormatter(responseItem);
      });
    }
  }]);
  return GetPastLogsMethod;
}(AbstractMethod);

function _createSuper$D(Derived) { return function () { var Super = _getPrototypeOf(Derived), result; if (_isNativeReflectConstruct$D()) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
function _isNativeReflectConstruct$D() { 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 GetEpochNumberMethod = function (_AbstractMethod) {
  _inherits(GetEpochNumberMethod, _AbstractMethod);
  var _super = _createSuper$D(GetEpochNumberMethod);
  function GetEpochNumberMethod(utils, formatters, moduleInstance) {
    _classCallCheck(this, GetEpochNumberMethod);
    return _super.call(this, 'cfx_epochNumber', 1, utils, formatters, moduleInstance);
  }
  _createClass(GetEpochNumberMethod, [{
    key: "beforeExecution",
    value: function beforeExecution(moduleInstance) {
      if (this.parameters[0] === undefined) {
        this.parameters[0] = 'latest_mined';
      }
      if (!this.formatters.isPredefinedEpochNumber(this.parameters[0])) {
        throw new Error('The epoch field must be predefined epoch number.');
      }
    }
  }, {
    key: "afterExecution",
    value: function afterExecution(response) {
      return this.utils.hexToNumber(response);
    }
  }]);
  return GetEpochNumberMethod;
}(AbstractMethod);

exports.AbstractGetBlockMethod = AbstractGetBlockMethod;
exports.AbstractGetBlockTransactionCountMethod = AbstractGetBlockTransactionCountMethod;
exports.AbstractGetTransactionFromBlockMethod = AbstractGetTransactionFromBlockMethod;
exports.AbstractMethod = AbstractMethod;
exports.AbstractMethodFactory = AbstractMethodFactory;
exports.AbstractObservedTransactionMethod = AbstractObservedTransactionMethod;
exports.CallMethod = CallMethod;
exports.CfxSendTransactionMethod = CfxSendTransactionMethod;
exports.ChainIdMethod = ChainIdMethod;
exports.EstimateGasMethod = EstimateGasMethod;
exports.GetAccountsMethod = GetAccountsMethod;
exports.GetBalanceMethod = GetBalanceMethod;
exports.GetBlockByHashMethod = GetBlockByHashMethod;
exports.GetBlockByNumberMethod = GetBlockByNumberMethod;
exports.GetBlockTransactionCountByHashMethod = GetBlockTransactionCountByHashMethod;
exports.GetBlockTransactionCountByNumberMethod = GetBlockTransactionCountByNumberMethod;
exports.GetCodeMethod = GetCodeMethod;
exports.GetCoinbaseMethod = GetCoinbaseMethod;
exports.GetEpochNumberMethod = GetEpochNumberMethod;
exports.GetGasPriceMethod = GetGasPriceMethod;
exports.GetHashrateMethod = GetHashrateMethod;
exports.GetNodeInfoMethod = GetNodeInfoMethod;
exports.GetPastLogsMethod = GetPastLogsMethod;
exports.GetProtocolVersionMethod = GetProtocolVersionMethod;
exports.GetStorageAtMethod = GetStorageAtMethod;
exports.GetTransactionByBlockAddressAndIndexMethod = GetTransactionByBlockAddressAndIndexMethod;
exports.GetTransactionByBlockHashAndIndexMethod = GetTransactionByBlockHashAndIndexMethod;
exports.GetTransactionCountMethod = GetTransactionCountMethod;
exports.GetTransactionMethod = GetTransactionMethod;
exports.GetTransactionReceiptMethod = GetTransactionReceiptMethod;
exports.GetWorkMethod = GetWorkMethod;
exports.IsMiningMethod = IsMiningMethod;
exports.IsSyncingMethod = IsSyncingMethod;
exports.ListeningMethod = ListeningMethod;
exports.MethodProxy = MethodProxy;
exports.PeerCountMethod = PeerCountMethod;
exports.PromiEvent = PromiEvent;
exports.RequestAccountsMethod = RequestAccountsMethod;
exports.SendRawTransactionMethod = SendRawTransactionMethod;
exports.SendTransactionMethod = SendTransactionMethod;
exports.SignMethod = SignMethod;
exports.SignTransactionMethod = SignTransactionMethod;
exports.SubmitWorkMethod = SubmitWorkMethod;
exports.TransactionObserver = TransactionObserver;
exports.VersionMethod = VersionMethod;